@manifest-editor/shell 1.0.0

package/index.d.ts

@@ -0,0 +1,1301 @@
+// Generated by dts-bundle-generator v6.13.0
+
+import { Collection, DescriptiveProperties, InternationalString, LinkingProperties, Manifest, MetadataItem, NavPlaceExtension, Reference, Service, SpecificResource, SpecificationTimeMode, StructuralProperties, TechnicalProperties, TextGranularityExtension, ViewingDirection } from '@iiif/presentation-3';
+import { AnnotationNormalized } from '@iiif/presentation-3-normalized';
+import { Vault } from '@iiif/vault';
+import { Emitter } from 'mitt';
+import * as React from 'react';
+import { Dispatch, HTMLAttributes, ReactNode, SetStateAction } from 'react';
+import { TransitionStatus } from 'react-transition-group';
+
+export type LoadedApp = Partial<LayoutProps> & {
+	default: {
+		id: string;
+		title: string;
+		type?: "manifest" | "launcher";
+		project?: boolean;
+		projectType?: "Manifest" | "Collection";
+		dev?: boolean;
+		desktop?: boolean;
+		web?: boolean;
+		drafts?: boolean;
+	};
+};
+export type MappedApp = {
+	metadata: LoadedApp["default"];
+	layout: LayoutProps;
+};
+export type AppDefinition = {
+	allApps: Record<string, MappedApp>;
+	allAppIds: string[];
+	allPaths: string[];
+};
+export interface Storage {
+	type: string;
+	error?: {
+		message: string;
+	};
+	data: any;
+}
+export interface ManifestStorage {
+	type: "manifest-storage";
+	data: Manifest;
+}
+export interface CollectionStorage {
+	type: "collection-storage";
+	data: Collection;
+}
+export interface RemoteWebsocketStorage {
+	type: "remote-websocket-storage";
+	data: {
+		id: string;
+		type: string;
+	};
+}
+export interface ResourceKeyedStorage {
+	type: "resource-keyed-storage";
+	data: {
+		id: string;
+		type: string;
+		key: string;
+	};
+}
+export interface Publication {
+	id: string;
+	type: string;
+	config: any;
+}
+export interface Preview {
+	id: string;
+	type: string;
+	data: any;
+}
+export interface ProjectState {
+	current: EditorProject | null;
+	allProjects: EditorProject[];
+	loadingStatus: null | ProjectsLoadingStatus;
+}
+export type ProjectContext = ProjectState & {
+	actions: ProjectActions;
+	canDelete: boolean;
+};
+export interface ProjectsLoadingStatus {
+	loading: boolean;
+	loaded: boolean;
+	lastLoaded: number;
+}
+export interface ProjectActions {
+	createProject(project: EditorProject): void;
+	deleteProject(id: string): void;
+	switchProject(id: string): void;
+	deselectProject(id: string): void;
+	forkProject(details: {
+		id: string;
+		name: string;
+		filename?: string;
+	}): void;
+	load(state: ProjectState): void;
+	setLoadingStatus(status: ProjectsLoadingStatus): void;
+	saveProject(project: EditorProject): Promise<void> | void;
+	updateDetails(details: {
+		name: string;
+		filename?: string;
+	}): void;
+	createPublication(publication: Publication): void;
+	updatePublication(publication: Publication): void;
+	removePublication(id: string): void;
+	setPreview(publication: Preview): void;
+	removePreview(id: string): void;
+	updateSettings(settings: EditorProject["settings"]): void;
+	updateThumbnail(url: string): void;
+	updateStorage(storage: Storage): void;
+}
+export type ProjectActionsType = {
+	[T in keyof ProjectActions]: {
+		type: T;
+		payload: Parameters<ProjectActions[T]>[0];
+	};
+}[keyof ProjectActions];
+export interface EditorProject {
+	id: string;
+	name: string;
+	filename?: string;
+	thumbnail?: string;
+	resource: {
+		id: string;
+		type: "Manifest";
+	} | {
+		id: string;
+		type: "Collection";
+	};
+	storage: Storage;
+	settings: Record<string, never>;
+	publications: Publication[];
+	previews: Preview[];
+	metadata: {
+		created: number;
+		modified: number;
+	};
+}
+export interface ProjectBackend {
+	saveInterval: number;
+	getAllProjects(fresh?: boolean): Promise<EditorProject[]>;
+	getLastProject(): Promise<string | null>;
+	setLastProject(id: string): Promise<void>;
+	canDelete(): boolean;
+	createProject(project: EditorProject): Promise<void>;
+	updateProject(project: EditorProject): Promise<void>;
+	deleteProject(id: string): Promise<void>;
+}
+export interface ProjectStorage<S extends Storage, DataType = any, Ref extends Storage = any> {
+	type: string;
+	saveInterval: number;
+	create(project: EditorProject, data: DataType): Promise<Ref | void>;
+	saveStorage(ref: Ref): Promise<void>;
+	deleteStorage(ref: Ref): Promise<void>;
+	canCreate(): boolean;
+	canDelete(): boolean;
+	getBackendStorage(project: EditorProject): Ref;
+	createVaultInstance(project: EditorProject): [
+		Vault,
+		Promise<void>
+	];
+	closeVaultInstance(project: EditorProject, vault: Vault): void;
+	shouldUpdateWithVault(): boolean;
+}
+export type AppContext = {
+	apps: Record<string, MappedApp>;
+	currentApp: {
+		id: string;
+		args?: any;
+	};
+	initialApp: {
+		id: string;
+		args?: any;
+	};
+	changeApp: (app: {
+		id: string;
+		args?: any;
+	}) => void;
+	editProject: (project: EditorProject) => void;
+};
+export type AppState = {
+	state: null | any;
+	setState: SetStateAction<any>;
+};
+export declare function useApps(): AppContext;
+export declare function useAppState<S = any>(): {
+	state: any;
+	setState: any;
+};
+export declare function AppStateProvider(props: {
+	appId: string;
+	initialValue?: any;
+	args?: any;
+	children: ReactNode;
+}): JSX.Element;
+export declare function AppProvider({ apps, initialApp, saveCurrentApp, children, }: {
+	apps: Record<string, MappedApp>;
+	initialApp?: AppContext["currentApp"];
+	saveCurrentApp?: boolean;
+	children: ReactNode;
+}): JSX.Element;
+export interface AppHeaderProps {
+	onClickLogo?: () => void;
+}
+export declare const AppHeader: import("react").NamedExoticComponent<AppHeaderProps>;
+export declare function useIsDesktop(): boolean;
+export declare function DesktopContext({ children }: {
+	children: ReactNode;
+}): JSX.Element;
+export type PreviewContext = PreviewState & {
+	handlers: Array<PreviewHandler>;
+	actions: PreviewActions;
+	configs: Array<PreviewConfiguration>;
+};
+export interface PreviewState {
+	selected: string | null;
+	active: string[];
+}
+export interface PreviewActions {
+	activatePreview(id: string): void;
+	updatePreviews(): void;
+	selectPreview(id: string): void;
+	deletePreview(id: string): void;
+	focusPreview(id: string): void;
+}
+export type PreviewActionsType = {
+	[T in keyof PreviewActions]: {
+		type: T;
+		payload: Parameters<PreviewActions[T]>[0];
+	};
+}[keyof PreviewActions];
+export interface PreviewConfiguration<Config = any> {
+	id: string;
+	type: string;
+	label: string;
+	config: Config;
+}
+export interface PreviewHandler {
+	id: string;
+	label: string;
+	type: string;
+	focusable: boolean;
+	getRequires(): string[];
+	getProvides(): string[];
+	isPreviewValid(project: EditorProject): boolean;
+	createPreview(project: EditorProject, vault: Vault, ctx: any): Promise<Preview>;
+	focus(project: EditorProject): Promise<void>;
+	updatePreview(project: EditorProject, vault: Vault, ctx: any): Promise<Preview | null>;
+	deletePreview(id: string): Promise<void>;
+}
+export interface Config {
+	previews: PreviewConfiguration[];
+	defaultLanguages: string[];
+	behaviorPresets: string[];
+	newTemplates: Collection | null;
+}
+export declare function useConfig(): Config;
+export declare function ConfigProvider({ children, config }: {
+	children: ReactNode;
+	config?: Partial<Config>;
+}): JSX.Element;
+export interface EditableResource {
+	parent?: Reference;
+	property?: string;
+	index?: number;
+	resource: SpecificResource;
+	onlyReference?: boolean;
+}
+export interface CreatableResource {
+	type: string;
+	parent?: Reference;
+	property?: string;
+	index?: number;
+	onlyReference?: boolean;
+	target?: Reference;
+	initialData?: any;
+	isPainting?: boolean;
+}
+export interface EditingStackState {
+	current: EditableResource | null;
+	stack: Array<EditableResource>;
+	create: {
+		resource: CreatableResource;
+		options: any;
+	} | null;
+}
+export interface EditingStackActions {
+	edit(resource: EditableResource | null, reset?: boolean): void;
+	updateCurrent(resource: Partial<EditableResource>): void;
+	close(): void;
+	back(): void;
+	create(resource: CreatableResource, options?: any): () => void;
+}
+export 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";
+};
+export interface EditorConfig {
+	vault: Vault;
+	reference: Reference;
+	context: {
+		resource: SpecificResource;
+		parent?: Reference;
+		parentProperty?: string;
+		index?: number;
+	};
+	tracker: TrackerState;
+	validators: Validator[];
+}
+export interface TrackerState {
+	key: string;
+	observed: string[];
+	start(onChange: () => void): () => void;
+	subscribe(cb: (entity: any) => void): () => void;
+	track(key: string): void;
+	reset(): void;
+}
+export interface Validator {
+	types: string[];
+	properties: string[];
+	message: string;
+	error?: boolean;
+	warning?: boolean;
+	valid: (resource: any, vault: Vault, context: any) => boolean;
+}
+export interface EntityValidationResponse {
+	isError: boolean;
+	isWarning: boolean;
+	problems: Array<{
+		isError: boolean;
+		isWarning: boolean;
+		message: string;
+		properties: string[];
+	}>;
+}
+declare class BaseEditor<T> {
+	protected config: EditorConfig;
+	constructor(config: EditorConfig);
+	protected entity(): T;
+	protected ref(): Reference;
+	protected getId(): string;
+	protected getType(): string;
+	focusId(): string;
+	protected _observe(selector: (resource: T, context: any, vault: Vault) => any, cb: (selected: any, resource: T, context: any) => void, skipInitial?: boolean): () => void;
+}
+declare class BasePropertyEditor<Entity, T> extends BaseEditor<Entity> {
+	protected property: string;
+	constructor(config: EditorConfig, property: string);
+	observe(cb: (selected: T, resource: Entity, context: any) => void, skipInitial?: boolean): void;
+	focusId(): string;
+	containerId(): string;
+	getContainerProps(): {
+		"data-property": string;
+		"data-resource-id": string;
+		"data-resource-type": string;
+	};
+	isRequired(): boolean;
+	isRecommended(): boolean;
+	isNotAllowed(): boolean;
+	isOptional(orRecommended?: boolean): boolean;
+	validate(): {
+		isError: boolean;
+		isWarning: boolean;
+		warnings: string[];
+		errors: string[];
+	};
+	getWithoutTracking(): T;
+	get(): T;
+	set(value: T): void;
+}
+declare class MetadataEditor<T> extends BasePropertyEditor<T, MetadataItem[]> {
+	protected cachedList: MetadataItem[] | undefined;
+	protected cachedSortableList: Array<{
+		id: string;
+	} & MetadataItem>;
+	protected idCache: Map<any, any>;
+	constructor(config: EditorConfig);
+	protected _getId(resource: any): any;
+	getSortable(): ({
+		id: string;
+	} & MetadataItem)[];
+	add(label: InternationalString, value: InternationalString, beforeIndex?: number): void;
+	update(atIndex: number, label: InternationalString, value: InternationalString): void;
+	deleteAtIndex(atIndex: number): void;
+	moveToStart(index: number): void;
+	moveToEnd(index: number): void;
+	reorder(startIndex: number, endIndex: number): void;
+}
+declare class RequiredStatementEditor<T> extends BasePropertyEditor<T, DescriptiveProperties["requiredStatement"]> {
+	constructor(config: EditorConfig);
+	updateLabel(text: string | InternationalString): void;
+	update(text: InternationalString): void;
+}
+declare class RightsStatementEditor<T> extends BasePropertyEditor<T, string> {
+	constructor(config: EditorConfig);
+	getClean(): string;
+	getDefinition(): {
+		label: string;
+		shortLabel: string;
+		description: string;
+		icon: string;
+		value: string;
+		url: string;
+		legal: string;
+	} | null;
+	getIcon(): string | undefined;
+	getOptions(): {
+		label: string;
+		shortLabel: string;
+		description: string;
+		icon: string;
+		value: string;
+		url: string;
+		legal: string;
+	}[];
+}
+declare class NavDateEditor<T> extends BasePropertyEditor<T, string | null> {
+	constructor(config: EditorConfig);
+	setDate(date: Date | null): void;
+	getDate(): Date | null;
+	modifyAsDate(fn: (date: Date) => void): void;
+}
+declare class InternationalStringEditor<Entity> extends BasePropertyEditor<Entity, InternationalString> {
+	constructor(config: EditorConfig, property: string);
+}
+declare class BaseReferenceListEditor<Entity, T> extends BasePropertyEditor<Entity, T[]> {
+	protected cachedList: T[] | undefined;
+	protected cachedSortableList: Array<Reference | ({
+		id: string;
+	} & SpecificResource)> | undefined;
+	protected idCache: Map<any, any>;
+	constructor(config: EditorConfig, property: string);
+	focusId(): string;
+	protected _getId(resource: any): any;
+	getSortable(): (Reference | ({
+		id: string;
+	} & import("@iiif/presentation-3").OtherProperties & {
+		role?: string | undefined;
+	} & {
+		id?: string | undefined;
+		type: "SpecificResource";
+		state?: import("@iiif/presentation-3").State | import("@iiif/presentation-3").State[] | undefined;
+		purpose?: import("@iiif/presentation-3").AnyMotivation | import("@iiif/presentation-3").AnyMotivation[] | undefined;
+		source?: any;
+		selector?: import("@iiif/presentation-3").Selector | import("@iiif/presentation-3").Selector[] | undefined;
+		styleClass?: string | undefined;
+		renderedVia?: import("@iiif/presentation-3").Agent | import("@iiif/presentation-3").Agent[] | undefined;
+		scope?: any;
+	}))[] | undefined;
+	get(): T[];
+	set(): void;
+	moveToStart(index: number): void;
+	moveToEnd(index: number): void;
+	deleteAtIndex(index: number): void;
+	addAfter(index: number, reference: Reference | SpecificResource): void;
+	addBefore(index: number, reference: Reference | SpecificResource): void;
+	add(reference: Reference | SpecificResource): void;
+	reorder(startIndex: number, endIndex: number): void;
+	moveUpBy(index: number, steps: number): void;
+	moveDownBy(index: number, steps: number): void;
+	private duplicate;
+	updateReference(index: number, item: Reference | SpecificResource): void;
+	private batchInsertAtIndex;
+}
+declare class DescriptiveEditor<T extends Partial<DescriptiveProperties>> extends BaseEditor<T> {
+	label: InternationalStringEditor<T>;
+	summary: InternationalStringEditor<T>;
+	metadata: MetadataEditor<T>;
+	requiredStatement: RequiredStatementEditor<T>;
+	rights: RightsStatementEditor<T>;
+	navDate: NavDateEditor<T>;
+	language: BasePropertyEditor<T, string[]>;
+	thumbnail: BaseReferenceListEditor<T, Reference<"ContentResource">>;
+	provider: BasePropertyEditor<T, Reference<"Agent">[]>;
+	placeholderCanvas: BasePropertyEditor<T, Reference<"Canvas">>;
+	accompanyingCanvas: BasePropertyEditor<T, Reference<"Canvas">>;
+	value: BasePropertyEditor<T, any>;
+	constructor(config: EditorConfig);
+}
+declare class SelfReferenceEditor<T> {
+	index: number;
+	private editor;
+	config: EditorConfig;
+	constructor(config: EditorConfig);
+	getSelector(): import("@iiif/presentation-3").Selector | import("@iiif/presentation-3").Selector[] | null;
+	updateReference(reference: Reference | SpecificResource): void;
+	moveToStart(): void;
+	moveToEnd(): void;
+	moveUpBy(steps: number): void;
+	moveDownBy(steps: number): void;
+	removeFromParent(): void;
+	addAfter(reference: Reference | SpecificResource): void;
+	addBefore(reference: Reference | SpecificResource): void;
+}
+declare class ReadonlyProperty<T, Prop> extends BasePropertyEditor<T, Prop> {
+	set(): void;
+}
+export interface BehaviorChoice {
+	id: string;
+	label: InternationalString;
+	type: "choice";
+	addNone?: boolean;
+	items: Array<{
+		value: string;
+		label: InternationalString;
+	}>;
+}
+declare class BehaviorEditor<T> extends BasePropertyEditor<T, string[]> {
+	constructor(config: EditorConfig);
+	getSupported(): BehaviorChoice[];
+}
+declare class TechnicalEditor<T extends Partial<TechnicalProperties>> extends BaseEditor<T> {
+	id: ReadonlyProperty<T, string>;
+	type: string;
+	mediaType: BasePropertyEditor<T, string>;
+	format: BasePropertyEditor<T, string>;
+	profile: BasePropertyEditor<T, string>;
+	height: BasePropertyEditor<T, number>;
+	width: BasePropertyEditor<T, number>;
+	duration: BasePropertyEditor<T, number>;
+	viewingDirection: BasePropertyEditor<T, ViewingDirection>;
+	behavior: BehaviorEditor<T>;
+	timeMode: BasePropertyEditor<T, SpecificationTimeMode | string | null>;
+	motivation: BasePropertyEditor<T, string | null>;
+	constructor(config: EditorConfig);
+}
+declare class LinkingEditor<T extends Partial<LinkingProperties>> extends BaseEditor<T> {
+	seeAlso: BaseReferenceListEditor<T, Reference<"ContentResource">>;
+	service: BaseReferenceListEditor<T, Service>;
+	services: BaseReferenceListEditor<T, Service>;
+	rendering: BaseReferenceListEditor<T, Reference<"ContentResource">>;
+	partOf: BaseReferenceListEditor<T, Reference<"ContentResource"> | Reference<"Canvas"> | Reference<"AnnotationCollection">>;
+	start: BasePropertyEditor<T, Reference<"Canvas"> | null>;
+	supplementary: BaseReferenceListEditor<T, Reference<"ContentResource">>;
+	homepage: BaseReferenceListEditor<T, Reference<"ContentResource">>;
+	logo: BaseReferenceListEditor<T, Reference<"ContentResource">>;
+	constructor(config: EditorConfig);
+}
+declare class StructuralEditor<T extends Partial<StructuralProperties<any>>> extends BaseEditor<T> {
+	items: BaseReferenceListEditor<T, Reference>;
+	annotations: BaseReferenceListEditor<T, Reference<"AnnotationPage">>;
+	structures: BaseReferenceListEditor<T, Reference<"Range">>;
+	constructor(config: EditorConfig);
+}
+declare class AnnotationTargetEditor extends BasePropertyEditor<AnnotationNormalized, SpecificResource> {
+	constructor(config: EditorConfig);
+	getSourceId(): any;
+	removeSelector(): void;
+	getParsedSelector(): import("@iiif/vault-helpers").SupportedSelectors | null;
+	setPosition(position: {
+		x: number;
+		y: number;
+		width: number;
+		height: number;
+	}): void;
+}
+declare class AnnotationBodyEditor extends BaseReferenceListEditor<AnnotationNormalized, Reference<"ContentResource"> | SpecificResource> {
+	constructor(config: EditorConfig);
+	isSpatial(): boolean;
+	hasBody(): boolean;
+	getFirst(): SpecificResource | Reference<"ContentResource">;
+	getFirstOrNone(): SpecificResource | Reference<"ContentResource"> | undefined;
+}
+declare class AnnotationEditor extends BaseEditor<AnnotationNormalized> {
+	target: AnnotationTargetEditor;
+	body: AnnotationBodyEditor;
+	constructor(config: EditorConfig);
+}
+declare class NavPlaceEditor<T> extends BasePropertyEditor<T, NavPlaceExtension["navPlace"]> {
+	constructor(config: EditorConfig);
+}
+declare class ExtensionsEditor<T extends Partial<NavPlaceExtension & TextGranularityExtension>> extends BaseEditor<T> {
+	navPlace: NavPlaceEditor<T>;
+	textGranularity: BasePropertyEditor<T, TextGranularityExtension["textGranularity"]>;
+	constructor(config: EditorConfig);
+}
+declare class EditorInstance<T extends Partial<DescriptiveProperties> & Partial<TechnicalProperties> & Partial<LinkingProperties> & Partial<StructuralProperties<unknown>> & Partial<NavPlaceExtension & TextGranularityExtension>> extends BaseEditor<T> {
+	technical: TechnicalEditor<T>;
+	descriptive: DescriptiveEditor<T>;
+	metadata: MetadataEditor<T>;
+	linking: LinkingEditor<T>;
+	structural: StructuralEditor<T>;
+	annotation: AnnotationEditor;
+	extensions: ExtensionsEditor<T>;
+	required: (keyof T)[];
+	recommended: (keyof T)[];
+	notAllowed: string[];
+	optional: (keyof T)[];
+	allowed: (keyof T)[];
+	isMultiple: boolean;
+	context?: SelfReferenceEditor<T>;
+	observe: TrackerState;
+	constructor(_config: {
+		vault: Vault;
+		reference: Reference;
+	} & Partial<EditorConfig>);
+	getPartOf(): string | null;
+	ref(): Reference;
+	validate(): EntityValidationResponse;
+}
+export declare function useEditingStack(): EditingStackActions;
+export declare function useEditingResource(): EditableResource | null;
+export declare function useEditingResourceStack(): EditableResource[];
+export declare function useCreatingResource(): {
+	resource: import("@/shell/EditingStack/EditingStack.types").CreatableResource;
+	options: any;
+} | null;
+export declare function useManifestEditor(): EditorInstance<Partial<import("@iiif/presentation-3").DescriptiveProperties> & Partial<import("@iiif/presentation-3").TechnicalProperties> & Partial<import("@iiif/presentation-3").LinkingProperties> & Partial<import("@iiif/presentation-3").StructuralProperties<unknown>> & Partial<import("@iiif/presentation-3").NavPlaceExtension & import("@iiif/presentation-3").TextGranularityExtension>>;
+export declare function useCollectionEditor(): EditorInstance<Partial<import("@iiif/presentation-3").DescriptiveProperties> & Partial<import("@iiif/presentation-3").TechnicalProperties> & Partial<import("@iiif/presentation-3").LinkingProperties> & Partial<import("@iiif/presentation-3").StructuralProperties<unknown>> & Partial<import("@iiif/presentation-3").NavPlaceExtension & import("@iiif/presentation-3").TextGranularityExtension>>;
+export declare function useGenericEditor(ref: Reference<any> | SpecificResource | undefined, ctx?: {
+	parent?: Reference;
+	parentProperty?: string;
+	index?: number;
+}): EditorInstance<Partial<import("@iiif/presentation-3").DescriptiveProperties> & Partial<import("@iiif/presentation-3").TechnicalProperties> & Partial<import("@iiif/presentation-3").LinkingProperties> & Partial<import("@iiif/presentation-3").StructuralProperties<unknown>> & Partial<import("@iiif/presentation-3").NavPlaceExtension & import("@iiif/presentation-3").TextGranularityExtension>>;
+export declare function useAnnotationPageEditor(): EditorInstance<Partial<import("@iiif/presentation-3").DescriptiveProperties> & Partial<import("@iiif/presentation-3").TechnicalProperties> & Partial<import("@iiif/presentation-3").LinkingProperties> & Partial<import("@iiif/presentation-3").StructuralProperties<unknown>> & Partial<import("@iiif/presentation-3").NavPlaceExtension & import("@iiif/presentation-3").TextGranularityExtension>>;
+export declare function useEditor(): EditorInstance<Partial<import("@iiif/presentation-3").DescriptiveProperties> & Partial<import("@iiif/presentation-3").TechnicalProperties> & Partial<import("@iiif/presentation-3").LinkingProperties> & Partial<import("@iiif/presentation-3").StructuralProperties<unknown>> & Partial<import("@iiif/presentation-3").NavPlaceExtension & import("@iiif/presentation-3").TextGranularityExtension>>;
+export declare function EditingStack(props: {
+	children?: any;
+}): JSX.Element;
+declare class ReferencedResource {
+	vault: Vault;
+	original: Reference | SpecificResource;
+	reference: Reference;
+	resource: SpecificResource;
+	constructor(reference: Reference | SpecificResource, vault: Vault);
+	ref(): Reference;
+	specificResource(): SpecificResource;
+	optionalSpecificResource(): Reference | {
+		source: {
+			id: any;
+			type: any;
+		};
+		created?: string | undefined;
+		generated?: string | undefined;
+		modified?: string | undefined;
+		creator?: import("@iiif/presentation-3").Creator | undefined;
+		generator?: import("@iiif/presentation-3").Creator | undefined;
+		audience?: import("@iiif/presentation-3").Audience | import("@iiif/presentation-3").Audience[] | undefined;
+		accessibility?: string | string[] | undefined;
+		motivation?: import("@iiif/presentation-3").AnyMotivation | import("@iiif/presentation-3").AnyMotivation[] | undefined;
+		rights?: string | string[] | undefined;
+		canonical?: string | undefined;
+		via?: string | string[] | undefined;
+		role?: string | undefined;
+		id?: string | undefined;
+		type: "SpecificResource";
+		state?: import("@iiif/presentation-3").State | import("@iiif/presentation-3").State[] | undefined;
+		purpose?: import("@iiif/presentation-3").AnyMotivation | import("@iiif/presentation-3").AnyMotivation[] | undefined;
+		selector?: import("@iiif/presentation-3").Selector | import("@iiif/presentation-3").Selector[] | undefined;
+		styleClass?: string | undefined;
+		renderedVia?: import("@iiif/presentation-3").Agent | import("@iiif/presentation-3").Agent[] | undefined;
+		scope?: any;
+	};
+	get(): any;
+}
+declare class CreatorResource {
+	resource: any;
+	warnings: string[];
+	errors: string[];
+	partOf: any;
+	references: ReferencedResource[];
+	embedded: CreatorResource[];
+	vault: Vault;
+	specificResource?: SpecificResource;
+	constructor(data: any, vault: Vault);
+	get(): any;
+	ref(): SpecificResource | {
+		id: any;
+		type: any;
+	};
+	getAllReferencedResources(): ReferencedResource[];
+	getAllEmbeddedResources(): CreatorResource[];
+	getVaultResource(): any;
+	setPartOf(id: string): void;
+}
+declare class CreatorInstance implements CreatorFunctionContext {
+	vault: Vault;
+	previewVault: Vault;
+	configs: CreatorDefinition[];
+	options: CreatorOptions;
+	constructor(vault: Vault, options: CreatorOptions, createConfigs: CreatorDefinition[], previewVault: Vault);
+	getPreviewVault(): Vault;
+	getTarget(): SpecificResource | Reference | undefined;
+	getParent(): Reference | undefined;
+	getParentResource(): SpecificResource | undefined;
+	generateId(type: string, parent?: Reference | ReferencedResource): string;
+	ref(idOrRef: string | Reference): ReferencedResource;
+	embed(data: any): CreatorResource;
+	create(definition: string, payload: any, options?: Partial<CreatorOptions>): Promise<CreatorResource>;
+}
+export interface CreatorContext<T = any> {
+	vault: Vault;
+	options: CreatorOptions;
+	validate: (payload: T) => Promise<boolean> | boolean;
+	runCreate: (payload: T) => void;
+}
+export interface CreatorFunctionContext {
+	options: CreatorOptions;
+	ref(idOrRef: string | Reference): ReferencedResource;
+	embed(data: any): CreatorResource;
+	create(definition: string, payload: any, options?: Partial<CreatorOptions>): Promise<CreatorResource>;
+	generateId(type: string, parent?: Reference | ReferencedResource): string;
+	getParent(): Reference | undefined;
+	getTarget(): SpecificResource | Reference | undefined;
+	getParentResource(): SpecificResource | undefined;
+	getPreviewVault(): Vault;
+}
+export interface CreatorParent {
+	resource: Reference;
+	property: string;
+	atIndex?: number;
+}
+export interface CreatorOptions {
+	targetType: string;
+	target?: Reference;
+	parent?: CreatorParent;
+	initialData?: any;
+}
+export interface CreatorDefinition {
+	id: string;
+	label: string;
+	summary?: string;
+	icon?: any;
+	dependencies?: string[];
+	create: (payload: any, ctx: CreatorInstance) => any | Promise<any>;
+	validate?: (payload: any, vault: Vault) => void | Promise<void>;
+	render?: (ctx: CreatorContext) => ReactNode;
+	renderCanvas?: (ctx: CreatorContext) => ReactNode | null;
+	renderModal?: (ctx: CreatorContext) => ReactNode;
+	resourceType: string;
+	additionalTypes?: string[];
+	resourceFields: string[];
+	embeddedResources?: string[];
+	staticFields?: Record<string, any>;
+	allowModal?: boolean;
+	supports: {
+		initialData?: boolean;
+		parentTypes?: string[];
+		parentFields?: string[];
+		parentFieldMap?: Record<string, string[]>;
+		custom?: (parent: CreatorParent, vault: Vault) => boolean;
+		disallowPainting?: boolean;
+	};
+	sideEffects?: Array<CreatorSideEffect>;
+}
+export interface CreatorSideEffect {
+	run?: (result: any, ctx: {
+		options: CreatorOptions;
+		vault: Vault;
+	}) => void | Promise<void>;
+	temporal?: boolean;
+	spatial?: boolean;
+	replaceSiblings?: boolean;
+	canvasInteraction?: boolean;
+}
+export interface LayoutProviderProps {
+	loading?: true;
+	leftPanels: Array<LayoutPanel>;
+	rightPanels: Array<LayoutPanel>;
+	centerPanels: Array<LayoutPanel>;
+}
+export interface LayoutContext extends LayoutProviderProps {
+	state: LayoutState;
+	actions: LayoutActions;
+}
+export interface LayoutState {
+	leftPanel: PanelState;
+	centerPanel: PanelState;
+	rightPanel: PanelState;
+	pinnedRightPanel: PinnablePanelState;
+}
+export interface LayoutActions {
+	setAvailable(panels: LayoutProviderProps): void;
+	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;
+	}): void;
+	create(resource: CreatableResource): void;
+	leftPanel: PanelActions;
+	centerPanel: PanelActions;
+	rightPanel: PanelActions;
+	pinnedRightPanel: PinnablePanelActions;
+}
+export interface PanelState {
+	current: string | null;
+	state: any;
+	open: boolean;
+	minimised: boolean;
+	customWidth?: number;
+	stack: Array<{
+		id: string;
+		state: any;
+	}>;
+}
+export 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;
+}
+export type PanelActionType = {
+	[T in keyof PinnablePanelActions]: {
+		type: T;
+		panel: keyof LayoutState;
+		payload: Parameters<PinnablePanelActions[T]>[0];
+	};
+}[keyof PinnablePanelActions];
+export interface PinnablePanelState extends PanelState {
+	pinnable: true;
+	pinned: boolean;
+}
+export interface PinnablePanelActions extends PanelActions {
+	pin(args: {
+		id: string;
+		state?: any;
+	}): void;
+	unpin(): void;
+}
+export type LayoutPanelContext = {
+	global: {
+		currentCanvasId: string | null;
+	};
+	current: {
+		actions: PanelActions;
+		state: any;
+	};
+	actions: LayoutActions;
+	state: LayoutState;
+};
+export type LayoutFunction = (state: any, ctx: {
+	current: PanelActions;
+	vault?: Vault;
+	transition?: TransitionStatus;
+} & LayoutContext, app: AppState) => ReactNode;
+export interface LayoutPanel {
+	id: string;
+	label: string;
+	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;
+	};
+}
+export type MenuPositions = "left" | "right" | "bottom" | "top";
+export interface PinnedLayoutPanel<T = any> extends LayoutPanel {
+	pinned: true;
+	state: T;
+}
+export 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: () => ReactNode;
+}
+export interface ResourceDefinition {
+	id: string;
+	label: string;
+	resourceType: string;
+	auto: boolean;
+	editors: EditorDefinition[];
+}
+export interface LayoutProps {
+	className?: string;
+	hideHeader?: boolean;
+	isProject?: boolean;
+	provider?: React.FC;
+	leftPanels: Array<LayoutPanel>;
+	rightPanels: Array<LayoutPanel>;
+	centerPanels: 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[];
+	miniEditor?: {
+		resource?: EditableResource;
+	};
+}
+export declare const Layout: import("react").NamedExoticComponent<LayoutProps>;
+export declare const HandleContainer: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const HandleControls: import("react").ForwardRefExoticComponent<{
+	dir: "left" | "right";
+	open: boolean;
+	actions: PanelActions;
+	transition?: TransitionStatus | undefined;
+	reset?: (() => void) | undefined;
+} & import("react").RefAttributes<HTMLDivElement>>;
+export interface ModularPanelProps {
+	panel?: LayoutPanel;
+	isLeft?: boolean;
+	state: PinnablePanelState | PanelState;
+	actions: PanelActions;
+	pinActions?: PinnablePanelActions;
+	transition?: TransitionStatus;
+	close?: () => void;
+	available?: LayoutPanel[];
+	style?: any;
+}
+export declare function useSetCustomTitle(): (title: string) => void;
+export declare const ModularPanelHeader: import("styled-components").StyledComponent<"div", any, {
+	$tabs?: boolean | undefined;
+	$error?: boolean | undefined;
+}, never>;
+export declare const ModulePanelButton: import("styled-components").StyledComponent<"button", any, {}, never>;
+export declare function ModularPanel({ panel, state, actions, isLeft, pinActions, transition, close, available, style, }: ModularPanelProps): JSX.Element | null;
+export declare function PanelError(props: {
+	error: Error;
+	resetErrorBoundary: () => void;
+}): JSX.Element;
+export declare const layoutReducer: (state: LayoutState, args_0: PanelActionType) => LayoutState;
+export declare function getDefaultPanelState(): PanelState;
+export declare function getDefaultLayoutState(): LayoutState;
+export declare function usePanelActions(panel: keyof LayoutState, dispatch: Dispatch<PanelActionType>): PanelActions | PinnablePanelActions;
+export declare const LayoutPropsReactContext: import("react").Context<LayoutProviderProps & {
+	loading?: true | undefined;
+}>;
+export declare const LayoutActionsReactContext: import("react").Context<LayoutActions>;
+export declare const LayoutStateReactContext: import("react").Context<LayoutState>;
+export declare function useLayoutState(): LayoutState;
+export declare function useLayoutActions(): LayoutActions;
+export declare function useAvailableLayouts(): LayoutProviderProps & {
+	loading?: true | undefined;
+};
+export declare function useLayoutProvider(): LayoutProviderProps & {
+	loading?: true;
+	actions: LayoutActions;
+	state: LayoutState;
+};
+export declare function isPinnableState(t: unknown): t is PinnablePanelState;
+export declare function panelSizing({ initial, fallback, options, }: {
+	initial?: number;
+	fallback: number;
+	options?: {
+		minWidth?: number;
+		maxWidth?: number;
+	};
+}): number;
+export declare function renderHelper(htmlOrReact: string | ReactNode): ReactNode;
+export declare const ProjectReactContext: import("react").Context<ProjectContext | null>;
+export declare const ProjectLoadingReactContext: import("react").Context<{
+	isLoading: boolean;
+	isError: boolean;
+	error?: string | undefined;
+}>;
+export declare function useProjectLoading(): {
+	isLoading: boolean;
+	isError: boolean;
+	error?: string | undefined;
+};
+export declare function useProjectContext(): ProjectContext;
+export declare function useCurrentProject(): EditorProject;
+export declare function useProjectActionsWithBackend(dispatch: Dispatch<ProjectActionsType>, backend: ProjectBackend, storage: ProjectStorage<any>): {
+	createProject: (payload: EditorProject) => Promise<void>;
+	deleteProject: (payload: string) => void;
+	switchProject: (payload: string) => void;
+	deselectProject: (payload: string) => void;
+	forkProject: (payload: {
+		id: string;
+		name: string;
+		filename?: string;
+	}) => void;
+	saveProject: (project: EditorProject) => void;
+	setLoadingStatus: (payload: ProjectsLoadingStatus) => void;
+	load: (payload: ProjectState) => void;
+	updateDetails: (payload: {
+		name: string;
+		filename?: string;
+	}) => void;
+	createPublication: (payload: Publication) => void;
+	updatePublication: (payload: Publication) => void;
+	removePublication: (payload: string) => void;
+	updateSettings: (payload: EditorProject["settings"]) => void;
+	updateThumbnail: (payload: string) => void;
+	updateStorage: (payload: Storage) => void;
+	setPreview: (publication: Preview) => void;
+	removePreview: (id: string) => void;
+};
+export declare function useProjectBackend({ actions, current }: ProjectContext, backend: ProjectBackend): void;
+export declare function useProjectLoader<T extends Storage = any>({ actions, current }: ProjectContext, storage: ProjectStorage<T>): {
+	vault: import("@iiif/vault/*").Vault | null;
+	ready: boolean;
+	error: string;
+};
+export declare function useProjectCreators(): {
+	createProjectFromManifestJson: (json: string) => Promise<void>;
+	createProjectFromManifestId: (id: string) => Promise<void>;
+	createProjectFromCollectionId: (id: string) => Promise<void>;
+	createBlankManifest: () => void;
+};
+export declare function projectFromCollection(collection: Collection, details?: Partial<EditorProject>): EditorProject;
+export declare function projectFromManifest(manifest: Manifest, details?: Partial<EditorProject>): EditorProject;
+export declare function ensureUniqueFilename(project: EditorProject, existing: EditorProject[]): void;
+export declare class LocalStorageBackend implements ProjectBackend {
+	namespace: string;
+	saveInterval: number;
+	storage: LocalForage;
+	constructor(settings?: {
+		namespace?: string;
+	});
+	deleteProject(id: string): Promise<void>;
+	createProject(project: EditorProject): Promise<void>;
+	canDelete(): boolean;
+	getAllProjects(): Promise<EditorProject[]>;
+	getLastProject(): Promise<string | null>;
+	setLastProject(id: string): Promise<void>;
+	updateProject(project: EditorProject): Promise<void>;
+	private saveProjectIndex;
+	private getProjectIndex;
+}
+export declare abstract class AbstractVaultLoader<T extends Storage> implements ProjectStorage<ManifestStorage | CollectionStorage, Manifest | Collection, T> {
+	abstract type: string;
+	vaults: Record<string, Vault | null>;
+	saveInterval: number;
+	protected constructor(config?: Partial<{
+		saveInterval: number;
+	}>);
+	shouldUpdateWithVault(): boolean;
+	canCreate(): boolean;
+	canDelete(): boolean;
+	abstract create(project: EditorProject, data: Manifest | Collection): Promise<T>;
+	createVaultInstance(project: EditorProject): [
+		Vault,
+		Promise<void>
+	];
+	closeVaultInstance(project: EditorProject, vault: Vault): void;
+	saveStorage(storage: T): Promise<void>;
+	abstract getStorage(storage: T): Promise<CollectionStorage | ManifestStorage | null>;
+	abstract saveStorageData(manifest: CollectionStorage | ManifestStorage, storage: T): void | Promise<void>;
+	abstract deleteStorage(storage: T): Promise<void>;
+	abstract getBackendStorage(project: EditorProject): T;
+}
+export declare class WebsocketLoader extends AbstractVaultLoader<RemoteWebsocketStorage> {
+	type: string;
+	baseUrl: string;
+	token: string;
+	constructor(settings: {
+		baseUrl: string;
+		token: string;
+	});
+	getStorage(storage: RemoteWebsocketStorage): Promise<CollectionStorage | ManifestStorage | null>;
+	shouldUpdateWithVault(): boolean;
+	create(project: EditorProject, data: Manifest | Collection): Promise<RemoteWebsocketStorage>;
+	canCreate(): boolean;
+	canDelete(): boolean;
+	createVaultInstance(project: EditorProject): [
+		Vault,
+		Promise<void>
+	];
+	closeVaultInstance(project: EditorProject, vault: Vault): void;
+	saveStorageData(manifestStorage: ManifestStorage | CollectionStorage, storage: RemoteWebsocketStorage): Promise<void>;
+	deleteStorage(storage: RemoteWebsocketStorage): Promise<void>;
+	getBackendStorage(project: EditorProject): RemoteWebsocketStorage;
+}
+export declare class LocalStorageLoader extends AbstractVaultLoader<ResourceKeyedStorage> {
+	type: string;
+	namespace: string;
+	storage: LocalForage;
+	vaults: Record<string, Vault | null>;
+	constructor(settings?: {
+		namespace?: string;
+	});
+	shouldUpdateWithVault(): boolean;
+	create(project: EditorProject, data: Manifest | Collection): Promise<ResourceKeyedStorage>;
+	getStorage(storage: ResourceKeyedStorage): Promise<CollectionStorage | ManifestStorage | null>;
+	saveStorageData(manifestStorage: ManifestStorage | CollectionStorage, storage: ResourceKeyedStorage): Promise<void>;
+	deleteStorage(storage: ResourceKeyedStorage): Promise<void>;
+	getBackendStorage(project: EditorProject): ResourceKeyedStorage;
+}
+export declare const PreviewProvider: import("react").NamedExoticComponent<{
+	children: ReactNode;
+	configs: PreviewConfiguration[];
+}>;
+export declare function usePreviewContext(): PreviewContext;
+export declare function usePreviewVault(): Vault;
+export declare const HOMEPAGE_COLLECTION = "manifest-editor://homepage-collection.json";
+export declare function usePreviewHistory(): {
+	addHistory: (id: string, type: string) => void;
+	clearHistory: () => void;
+};
+export declare function PreviewVaultContext(props: {
+	children: any;
+}): JSX.Element;
+export declare function PreviewVaultBoundary({ children }: {
+	children: any;
+}): JSX.Element;
+export declare function createPreviewVault(homepageCollectionId?: string): {
+	readonly vault: Vault;
+	readonly unsubscribe: () => void;
+	readonly addHistory: (id: string, type: string) => void;
+	readonly clearHistory: () => void;
+};
+export interface ResourceEditingContext {
+	resource: Reference<any> | null;
+}
+export declare function useEditingContext(): ResourceEditingContext;
+/**
+ * useResource
+ *
+ * Only use this if you KNOW that there is a resource (e.g. in a panel)
+ */
+export 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)
+ */
+export declare function useOptionalResource(): Reference<any> | null;
+export declare function ResourceEditingProvider({ resource, children, }: {
+	resource: {
+		id: string;
+		type: string;
+	} | null | undefined;
+	children: ReactNode;
+}): JSX.Element;
+export interface ProjectProviderProps {
+	children: ReactNode;
+	defaultApp?: string;
+	storage?: AbstractVaultLoader<any>;
+	backend?: ProjectBackend;
+	initialState?: () => ProjectState;
+}
+export declare const ShellProvider: ({ config, children, theme, saveCurrentApp, apps, initialApp, project, }: {
+	config?: Partial<Config> | undefined;
+	children: ReactNode;
+	theme?: any;
+	saveCurrentApp?: boolean | undefined;
+	apps: AppDefinition;
+	initialApp?: {
+		id: string;
+		args?: any;
+	} | undefined;
+	project?: Partial<ProjectProviderProps> | undefined;
+}) => JSX.Element;
+export 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;
+}
+export declare function useTask(name: string): Task<any, any>;
+export declare function useTaskEvent<Req = any, Res = any>(task: Task<Req, Res>, name: string, _cb: (task: Task<Req, Res>) => any): void;
+export declare function useTaskDispatch<Req = any, Res = any>(name: string, onComplete?: (task: Task<Req, Res>) => void | Promise<void>): readonly [
+	(request?: any) => void,
+	Task<any, any>
+];
+export 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
+];
+export declare function TaskBridge({ children }: {
+	children?: ReactNode;
+}): JSX.Element;
+export 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;
+}
+export 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): JSX.Element;
+export declare namespace JSX {
+	interface IntrinsicElements {
+		"canvas-panel": any;
+	}
+}
+
+export {};