@webx-ui/module-admin 0.23.5 → 0.24.0

package/dist/DraftsList.d.ts

@@ -0,0 +1,21 @@
+type __VLS_Props = {
+    /** The record's name on the server's `editing/{entity}/{id}`. */
+    entity: string;
+    id: string | number | null | undefined;
+    /** Whether this reader may put a copy back. */
+    canRestore?: boolean;
+    /** Anything that changes when the record is saved or published: the list is read again. */
+    stamp?: unknown;
+    /** The screen the record is edited on, so the changed places read as the form names them. */
+    screen?: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    restored: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onRestored?: (() => any) | undefined;
+}>, {
+    screen: string;
+    canRestore: boolean;
+    stamp: undefined;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/EditingAlerts.d.ts

@@ -0,0 +1,114 @@
+import { nextTick } from 'vue';
+import { Editing } from './editing';
+/**
+ * What an editor says about other people editing the same record, above its form.
+ *
+ * Six things, the loudest first. The record was deleted for good, with a way to copy out what was
+ * typed. The record is in the bin, with the way out of it. A conflict: both sides changed the same place, and each such
+ * place is listed with what it was, what this editor wrote and what the other side wrote, to be
+ * settled one by one — everything else has already been merged. A save that came in while this
+ * editor was open, with what it changed and an offer to pull it in before saving over it. What
+ * others did besides writing — published it, moved it, put an old version back. And,
+ * quietest, who else has the record open right now.
+ */
+type __VLS_Props = {
+    editing: Editing<unknown>;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    save: () => any;
+    theirs: () => any;
+    pulled: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSave?: (() => any) | undefined;
+    onTheirs?: (() => any) | undefined;
+    onPulled?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    conflictAlert: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly visible?: boolean | undefined;
+            readonly type?: import('@webx-ui/core').AlertType | undefined;
+            readonly variant?: import('@webx-ui/core').AlertVariant | undefined;
+            readonly title?: string | undefined;
+            readonly description?: string | undefined;
+            readonly icon?: (import('@webx-ui/core').IconName | false) | undefined;
+            readonly closable?: boolean | undefined;
+            readonly closeLabel?: string | undefined;
+            readonly live?: boolean | undefined;
+            readonly onClose?: ((event: MouseEvent) => any) | undefined | undefined;
+            readonly "onUpdate:visible"?: ((value: boolean) => any) | undefined | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: import('vue').Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "close", event: MouseEvent) => void) & ((event: "update:visible", value: boolean) => void);
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<{
+            visible?: boolean;
+        } & import('@webx-ui/core').AlertProps> & Readonly<{
+            onClose?: ((event: MouseEvent) => any) | undefined;
+            "onUpdate:visible"?: ((value: boolean) => any) | undefined;
+        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            close: (event: MouseEvent) => any;
+            "update:visible": (value: boolean) => any;
+        }, string, {
+            variant: import('@webx-ui/core').AlertVariant;
+            type: import('@webx-ui/core').AlertType;
+            title: string;
+            icon: import('@webx-ui/core').IconName | false;
+            description: string;
+            closable: boolean;
+            closeLabel: string;
+            live: boolean;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        variant: import('@webx-ui/core').AlertVariant;
+        type: import('@webx-ui/core').AlertType;
+        title: string;
+        icon: import('@webx-ui/core').IconName | false;
+        description: string;
+        closable: boolean;
+        closeLabel: string;
+        live: boolean;
+    }> & Omit<Readonly<{
+        visible?: boolean;
+    } & import('@webx-ui/core').AlertProps> & Readonly<{
+        onClose?: ((event: MouseEvent) => any) | undefined;
+        "onUpdate:visible"?: ((value: boolean) => any) | undefined;
+    }>, "type" | "icon" | "title" | "variant" | "closable" | "closeLabel" | "description" | "live"> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            icon?(_: {}): any;
+            title?(_: {}): any;
+            default?(_: {}): any;
+            actions?(_: {}): any;
+        };
+    }) | null;
+}, any>;
+export default _default;

package/dist/RenameButton.d.ts

@@ -49,6 +49,9 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {
             readonly autocomplete?: string | undefined;
             readonly ariaLabel?: string | undefined;
             readonly localized?: boolean | undefined;
+            readonly tokens?: import('@webx-ui/core').TokenOption[] | undefined;
+            readonly tokensTitle?: string | undefined;
+            readonly tokensLabel?: string | undefined;
             readonly onChange?: ((value: string) => any) | undefined | undefined;
             readonly "onUpdate:modelValue"?: ((value: import('@webx-ui/core').InputModelValue) => any) | undefined | undefined;
             readonly onInput?: ((value: string) => any) | undefined | undefined;
@@ -60,7 +63,9 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {
         $refs: {
             [x: string]: unknown;
         } & {
+            rootRef: HTMLDivElement;
             inputRef: HTMLInputElement;
+            mirrorRef: HTMLSpanElement;
         };
         $slots: Readonly<{
             [name: string]: import('vue').Slot<any> | undefined;
@@ -105,6 +110,9 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {
             maxlength: number;
             showCount: boolean;
             localized: boolean;
+            tokens: import('@webx-ui/core').TokenOption[];
+            tokensTitle: string;
+            tokensLabel: string;
         }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
             beforeCreate?: (() => void) | (() => void)[];
             created?: (() => void) | (() => void)[];
@@ -139,6 +147,9 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {
         maxlength: number;
         showCount: boolean;
         localized: boolean;
+        tokens: import('@webx-ui/core').TokenOption[];
+        tokensTitle: string;
+        tokensLabel: string;
     }> & Omit<Readonly<{
         modelValue?: import('@webx-ui/core').InputModelValue;
     } & import('@webx-ui/core').InputProps> & Readonly<{
@@ -148,7 +159,7 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {
         onClear?: (() => any) | undefined;
         onBlur?: ((event: FocusEvent) => any) | undefined;
         onFocus?: ((event: FocusEvent) => any) | undefined;
-    }>, "disabled" | "type" | "id" | "size" | "clearable" | "placeholder" | "status" | "ariaLabel" | "input" | "select" | "readonly" | "focus" | "blur" | "maxlength" | "showCount" | "autocomplete" | "localized"> & {
+    }>, "disabled" | "type" | "id" | "size" | "clearable" | "placeholder" | "status" | "ariaLabel" | "input" | "select" | "readonly" | "focus" | "blur" | "maxlength" | "showCount" | "autocomplete" | "localized" | "tokens" | "tokensTitle" | "tokensLabel"> & {
         focus: () => void | undefined;
         blur: () => void | undefined;
         select: () => void | undefined;

package/dist/admin.d.ts

@@ -3,7 +3,7 @@ import { Patch, ScreenNode, TypeRegistry } from '@webx-ui/schema';
 import { Http } from './http';
 import { I18n } from './i18n';
 import { ThemeController } from './theme';
-import { AdminModule, AdminStatus, AdminUser, Manifest, NavEntry, NavGroup, PickedImage } from './types';
+import { AdminModule, AdminStatus, AdminUser, BlockLabels, Manifest, NavEntry, NavGroup, PickedImage } from './types';
 export interface AdminContext {
     /** The panel's own backend. */
     readonly http: Http;
@@ -35,6 +35,11 @@ export interface AdminContext {
      * does, and a document is then shown with the addresses it was saved with.
      */
     readonly assetUrls: ((paths: string[]) => Promise<Record<string, string | null>>) | null;
+    /**
+     * Names of block types and their fields, when a module installed here has a block library;
+     * fetched once for the session. Optional on the context so a hand-made one in a test needs none.
+     */
+    readonly blockLabels?: () => Promise<BlockLabels | null>;
     /** Ask the server what the panel is and who is signed in again. */
     reload(): Promise<void>;
     /**

package/dist/editing.d.ts

@@ -0,0 +1,204 @@
+import { ComputedRef, Ref, ShallowRef } from 'vue';
+import { MergeChoice, MergeConflict, MergeSegment } from './merge';
+/** Who wrote a record last, through which door, and when — the server's `changed`. */
+export interface EditingChange {
+    author: string | null;
+    author_id: number | null;
+    /** `panel`, `mcp` (an agent) or `import`. */
+    source: string;
+    at: string | null;
+}
+/** Somebody else who has the record open in the panel right now. */
+export interface EditingEditor {
+    id: number;
+    name: string;
+    since: string;
+    seen_at: string;
+}
+/** Where the record stands, as the heartbeat reports it. */
+export interface EditingState {
+    status: string;
+    has_draft: boolean;
+    published_at: string | null;
+    trashed: boolean;
+    deleted_at: string | null;
+}
+/**
+ * Something that happened to the record besides its content: published, taken off the site, its
+ * draft thrown away, an old version put back, moved, put in the bin or taken out of it.
+ */
+export interface EditingEvent {
+    id: number;
+    kind: 'published' | 'unpublished' | 'discarded' | 'restored_version' | 'moved' | 'trashed' | 'restored' | 'purged' | string;
+    author: string | null;
+    author_id: number | null;
+    source: string;
+    at: string;
+    detail: Record<string, unknown> | null;
+}
+/** One copy of the draft, as `editing/{entity}/{id}/drafts` lists it. */
+export interface DraftCopy {
+    id: number;
+    kind: 'autosave' | 'overwritten';
+    created_at: string | null;
+    author: string | null;
+    source: string;
+    fields: string[];
+    /** What this copy changed against the one before it. */
+    paths?: MergeSegment[][];
+}
+/** The record as the server has it now. */
+export interface EditingVersion<T> {
+    values: T;
+    revision: string;
+    changed?: EditingChange | null;
+}
+export interface EditingConflict<T> {
+    /** The places both sides changed, each with its three values. */
+    conflicts: MergeConflict[];
+    /** The side each one is settled to; this editor's until somebody picks. */
+    choices: Record<string, MergeChoice>;
+    theirs: EditingVersion<T>;
+}
+/** Somebody else saved while this editor is open, and it has not been pulled in yet. */
+export interface EditingIncoming<T> {
+    theirs: EditingVersion<T>;
+    paths: MergeSegment[][];
+}
+export interface EditingOptions<T> {
+    /** The record's name on the server's `editing/{entity}/{id}`: `pages`, `services`, `regions`. */
+    entity: string;
+    id: () => string | number | null | undefined;
+    /** The form: what this editor has now. */
+    values: Ref<T>;
+    /** The revision the form was read at; a merge moves it to the one it merged with. */
+    revision: Ref<string>;
+    /** Read the record again, for the notice's «Pull in». */
+    read: () => Promise<EditingVersion<T>>;
+    /**
+     * The server's version was taken in as the new base — after a merge, a pull or «Take theirs».
+     * The editor moves its own idea of "saved" there: whatever differs from it now is unsaved.
+     */
+    adopt?: (theirs: EditingVersion<T>) => void;
+    /**
+     * Somebody published, unpublished, moved or restored the record: read what the editor shows
+     * around the form again — the status, the trail, the address — without touching the form.
+     */
+    refresh?: () => void | Promise<void>;
+    /** Take the record out of the bin. Without it, the notice of the bin offers no way back. */
+    restore?: () => Promise<void>;
+    /** Whether this editor writes at all; a reader is not asked about anybody's changes. */
+    canWrite?: () => boolean;
+    /** Whether a save is on its way: a heartbeat answered meanwhile may be reporting it. */
+    busy?: () => boolean;
+    /** The screen the record is edited on, so its fields are named the way the form names them. */
+    screen?: string;
+    /** What a top-level field is called on screen, for the conflict list. */
+    field?: (name: string) => string | undefined;
+    /** What a type of block is called. */
+    block?: (type: string) => string | undefined;
+    /** Seconds between heartbeats; `false` for none (a test, a screen that is not an editor). */
+    heartbeat?: number | false;
+}
+export interface Editing<T> {
+    /** What the form was opened with, or last saved — the common ancestor of a merge. */
+    base: ShallowRef<T>;
+    conflict: Ref<EditingConflict<T> | null>;
+    incoming: Ref<EditingIncoming<T> | null>;
+    editors: Ref<EditingEditor[]>;
+    /** Where the record stands, by the last heartbeat. */
+    state: Ref<EditingState | null>;
+    /** What others did to the record since this editor opened it, not yet acknowledged. */
+    events: Ref<EditingEvent[]>;
+    /** The record is in the bin. */
+    trashed: ComputedRef<boolean>;
+    /** Who put it there and when, when the server knows. */
+    trashedBy: ComputedRef<EditingEvent | null>;
+    /**
+     * The record was deleted for good: who did it and when. Nothing can be saved or restored —
+     * the form keeps what it holds, to be copied out with `copyText`.
+     */
+    gone: Ref<EditingEvent | null>;
+    /** In the bin or gone: autosave waits, and a save would only fail. */
+    stopped: ComputedRef<boolean>;
+    /**
+     * Why Save and Publish are off, for their `title`: «This is in the bin», «This was deleted for
+     * good». `undefined` while they are not — a disabled button with no reason looks frozen.
+     */
+    blocked: ComputedRef<string | undefined>;
+    /** Whether the form holds something the server does not. */
+    unsaved: ComputedRef<boolean>;
+    /** Whether this editor can take the record out of the bin. */
+    canRestore: () => boolean;
+    /** Call with what the form now matches on the server: on opening, and after each save. */
+    opened(values: T): void;
+    /**
+     * A save was refused because the record moved. Merges it with what is in the form: `true`
+     * when nothing overlapped — the form holds both edits and the editor saves it again — and
+     * `false` when a conflict is waiting for the person.
+     */
+    refused(theirs: EditingVersion<T>): boolean;
+    /** Pull the other side's save in before saving. Same answer as `refused`. */
+    pull(): Promise<boolean>;
+    choose(id: string, choice: MergeChoice): void;
+    /** Settle the conflict by the choices; the editor saves next. */
+    resolve(): void;
+    /** Settle every conflict their way at once. */
+    resolveTheirs(): void;
+    /**
+     * Before publishing: whether the draft on the server is still the one this editor holds. When
+     * somebody else changed it, the person is told whose changes, where and when, and chooses to
+     * publish with them or to review them first — which pulls them into the form. Answers the
+     * revision to publish with, and whether the person was already asked; `null` to stop.
+     */
+    beforePublish(): Promise<{
+        revision: string;
+        asked: boolean;
+    } | null>;
+    /**
+     * A save or a publication failed. `true` when this was about other people — the record is in
+     * the bin, or a publication found a draft it had not seen — and a notice says so; the editor
+     * then shows nothing of its own.
+     */
+    failed(error: unknown): Promise<boolean>;
+    /** Out of the bin. The form keeps what it holds; saving it is the caller's next step. */
+    restoreFromBin(): Promise<boolean>;
+    /** What the form holds, as text a person can paste somewhere else: each field under its name. */
+    text(): string;
+    /** That text onto the clipboard, said with a toast either way. */
+    copyText(): Promise<boolean>;
+    /** The events have been read. */
+    dismissEvents(): void;
+    /** Ask the server now rather than at the next heartbeat. */
+    check(): Promise<void>;
+    /** A place in the record as the person reads it: «Hero › Heading · EN». */
+    label(path: MergeSegment[]): string;
+    /** What a list of changed places says: «Hero › Heading, Title · EN and more». */
+    places(paths: MergeSegment[][]): string;
+    /** What happened, in a sentence: «Owner restored version 21 and published · 16:40». */
+    describe(events: EditingEvent[]): string;
+    /** A value, short, as text. */
+    preview(value: unknown): string;
+    /** Who changed it: «Anna», «Anna, through an agent». */
+    who(changed: EditingChange | null | undefined): string;
+}
+/**
+ * What every drafted editor does about other people editing the same record (§ «Two editors»):
+ * merges a refused save instead of asking, asks only about a field both sides changed, says who
+ * the other side was and through which door, and keeps an ear on the server while open — who
+ * else has the record, whether somebody saved in the meantime, and what they did to it besides
+ * saving: published it, moved it, put it in the bin.
+ *
+ * The editor keeps its own save loop; this is the part that is the same in all of them.
+ */
+export declare function useEditing<T>(options: EditingOptions<T>): Editing<T>;
+/** A value, short, as text: the words of a rich text without its tags, a block by its type. */
+export declare function preview(value: unknown): string;
+/**
+ * Every piece of text in a value with where it sits — what a person typed, to be carried out of
+ * a form whose record is gone. Rich text comes out as its words, a paragraph to a line; a block's
+ * own `key` and `type` are its shape, not anything anybody wrote.
+ */
+export declare function texts(value: unknown, path?: MergeSegment[]): [MergeSegment[], string][];
+/** A sentence whose time was not known ends where the time would have been, not on a «·». */
+export declare function timeless(text: string): string;

package/dist/editingLabels.d.ts

@@ -0,0 +1,26 @@
+import { ScreenNode } from '@webx-ui/schema';
+import { MergeSegment } from './merge';
+export interface EditingLabelsOptions {
+    /** The screen the record is edited on: its fields are named the way the form names them. */
+    screen?: string;
+    /** What a top-level field is called, when the editor knows better than the screen. */
+    field?: (name: string) => string | undefined;
+    /** What a type of block is called, when the editor knows better than the block library. */
+    block?: (type: string) => string | undefined;
+}
+export interface EditingLabels {
+    /** A place in the record as the person reads it: «Hero › Eyebrow · EN». */
+    label(path: MergeSegment[]): string;
+}
+/**
+ * Names for the places in a record, the way the person who edits it knows them.
+ *
+ * A notice that says «Hero › Below cta · EN» has turned `below_cta` into words by guessing; the
+ * block type calls that field «Text below the button», and that is the name the person looks for
+ * in the form. The screen names the record's own fields, the block library names the blocks and
+ * their fields, and a key nobody named is turned into words as a last resort.
+ */
+export declare function useEditingLabels(options?: EditingLabelsOptions): EditingLabels;
+/** Every named field of a screen tree with its label, wherever it sits — in a tab, in a card. */
+export declare function screenLabels(root: ScreenNode[]): Map<string, string>;
+export declare function humanize(name: string): string;

package/dist/index.d.ts

@@ -5,18 +5,23 @@ export { createTheme, provideTheme, useTheme, themeKey, type CreateThemeOptions,
 export { adminMessages } from './messages';
 export { renderMarkdown } from './markdown';
 export { createDates, useDates, type DateLike, type Dates } from './dates';
+export { pluralForm, type PluralForm } from './plural';
 export { errorText, useErrorText } from './errors';
 export { useBodyKeys } from './keys';
+export { changedPaths, conflictId, mergeThreeWay, sameValue, type MergeChoice, type MergeConflict, type MergeResult, type MergeSegment, } from './merge';
+export { preview as previewValue, useEditing, type DraftCopy, type Editing, type EditingChange, type EditingConflict, type EditingEditor, type EditingIncoming, type EditingOptions, type EditingEvent, type EditingState, type EditingVersion, } from './editing';
+export { screenLabels, useEditingLabels, type EditingLabels, type EditingLabelsOptions, } from './editingLabels';
 export { createNotesApi, type EntityNote, type NoteAuthor, type NotesApi } from './notes';
 export { createHistoryApi, historySubjectKey, historyValue, provideHistorySubject, useHistorySubject, type HistoryApi, type HistoryChange, type HistoryEntry, type HistoryEvent, type HistoryPage, type HistoryRun, type HistorySource, type HistorySubject, } from './history';
 export { createLinksApi, emptyLink, type LinkCandidate, type LinkRel, type LinkSourceInfo, type LinkTarget, type LinkValue, type LinksApi, type ResolvedLink, } from './links';
+export { forgetShortcodes, loadShortcodes, shortcodeToken, useShortcodes, type Shortcode, type ShortcodeToken, } from './shortcodes';
 export { createHttp, readCookie, HttpError, type Http, type HttpOptions, type RequestOptions, type SendOptions, } from './http';
 export { forgetUnfinishedUpload, MIN_CHUNK, unfinishedUploads, uploadFingerprint, useChunkedUpload, type ChunkedUpload, type ChunkedUploadOptions, type ChunkedUploadState, type UnfinishedUpload, } from './uploads';
 export { adminTypes } from './screenTypes';
 export { categoryRoutes, categoryEditorKey, createCategoriesApi, itemOrderMode, provideCategoryEditor, reorderItems, useCategoryEditor, useCategoryWords, useItemOrder, type CategoriesApi, type CategoriesOptions, type CategoriesPayload, type CategoryDetail, type CategoryEditorContext, type CategoryRow, type CategoryWord, type ItemOrder, type ItemOrderMode, type ItemOrderState, } from './categories';
 export { COLLECTION_MAX_LIMIT, collectionSources, defaultMarkup, normaliseCollection, type CollectionRelated, type CollectionRelationTarget, type CollectionSourceInfo, type CollectionValue, } from './collections/api';
 export { createRelationsApi, normaliseRelations, provideRelationOwner, relationOwnerKey, useRelationOwner, type RelationCandidate, type RelationOwner, type RelationsApi, } from './relations/api';
-export type { AdminModule, AdminStatus, AdminUser, Manifest, ManifestModule, NavEntry, PickedImage, RowAction, ScreenAction, AppliedFilter, } from './types';
+export type { AdminModule, AdminStatus, AdminUser, BlockLabels, Manifest, ManifestModule, NavEntry, PickedImage, RowAction, ScreenAction, AppliedFilter, } from './types';
 export { default as AdminShell } from './AdminShell';
 export { default as AdminNav } from './AdminNav';
 export { default as AdminLanding } from './AdminLanding';
@@ -34,6 +39,8 @@ export { default as WxHelpButton } from './HelpButton';
 export { default as WxDate } from './DateText';
 export { default as WxNotes } from './NotesFeed';
 export { default as WxHistory } from './HistoryFeed';
+export { default as WxEditingAlerts } from './EditingAlerts';
+export { default as WxDrafts } from './DraftsList';
 export { default as WxBackupNote } from './BackupNote';
 export { default as WxRichTextField } from './RichTextField';
 export { default as WxLinkPicker } from './LinkPicker';