@box/metadata-template-editor 1.19.0

package/dist/types/lib/components/metadata-field-configurator/messages/taxonomy-messages.d.ts

@@ -0,0 +1,43 @@
+declare const _default: {
+    callToActionHeader: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    callToActionSubheader: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    allowMultipleTaxonomySelections: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    selection: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    requiredSelection: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    anyLevelSelection: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    chooseTaxonomyLevel: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    noTaxonomySelectedError: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+};
+export default _default;

package/dist/types/lib/components/metadata-field-configurator/metadata-field-configurator.d.ts

@@ -0,0 +1,191 @@
+import { DraggableAttributes } from '@dnd-kit/core';
+import { useSortable } from '@dnd-kit/sortable';
+import { default as React } from 'react';
+import { FieldConfiguratorExtension } from './context/field-extensions-context';
+import { FieldData, TaxonomyOption } from '../../types';
+type ValidatableFieldNames = 'name' | 'description' | 'key' | 'type' | 'hidden' | 'taxonomy' | 'dropdown';
+/** Externally supplied validation state that overrides internal errors when present. */
+export type GeneralComponentProps = {
+    /** Per-field error messages injected from outside (e.g., server-side validation). */
+    externalErrors?: Partial<Record<ValidatableFieldNames, string>>;
+    /** Marks which fields have been touched so `externalErrors` are actually displayed. */
+    externalTouched?: Partial<Record<ValidatableFieldNames, boolean>>;
+};
+/** Props for dnd-kit drag handle integration. */
+export type DndDragHandleProps = {
+    /** dnd-kit pointer/keyboard event listeners to spread onto the drag handle element. */
+    listeners?: ReturnType<typeof useSortable>['listeners'];
+    /** dnd-kit ARIA attributes to spread onto the drag handle element. */
+    attributes?: DraggableAttributes;
+};
+/** Drag props when using native HTML5 drag events (no dnd-kit integration). */
+type NativeDragProps = {
+    /** Must be `undefined` to distinguish from dnd-kit mode. */
+    dndDragHandleProps?: undefined;
+    /** Called when the user starts dragging the field handle. */
+    onDragStart: (event: React.DragEvent<HTMLDivElement>, index: number) => void;
+    /** Called when the drag operation ends (dropped or cancelled). */
+    onDragEnd: (event: React.DragEvent<HTMLDivElement>, index: number) => void;
+    /** Called when the user touches the drag handle on a touch device. */
+    onTouchStart: (event: React.TouchEvent<HTMLDivElement>, index: number) => void;
+};
+/** Drag props when using dnd-kit sensors for drag-and-drop (mutually exclusive with NativeDragProps). */
+type DndKitDragProps = {
+    /** dnd-kit listeners and ARIA attributes for the drag handle. */
+    dndDragHandleProps: DndDragHandleProps;
+    onDragStart?: never;
+    onDragEnd?: never;
+    onTouchStart?: never;
+};
+/**
+ * Fully controlled component for configuring a single metadata template field.
+ *
+ * The parent owns all form state and passes it down via props.
+ * Sub-components access the state through {@link FieldConfiguratorContext}
+ * (see {@link FieldConfiguratorContextValue}).
+ *
+ * Validation (Yup schema, touched tracking, error messages) is handled internally.
+ * Supply `externalErrors` / `externalTouched` only for server-side errors.
+ */
+export type MetadataFieldConfiguratorProps = GeneralComponentProps & (NativeDragProps | DndKitDragProps) & {
+    /** Zero-based position of this field in its parent list. */
+    index: number;
+    /** Index of the last field; used to disable the "Move down" action on the last item. */
+    maxIndex?: number;
+    /** Current field data — the single source of truth. */
+    values: FieldData;
+    /** Called on every values change. The parent should persist the new values in state. */
+    onValuesChange: (values: FieldData) => void;
+    /** Called with the field key when the user confirms deletion. */
+    onDelete?: (key: string) => void;
+    /** Called when the user requests to duplicate this field. The parent is responsible for creating and inserting the copy. */
+    onDuplicate: () => void;
+    /** Called with source and destination indices when the user reorders this field. */
+    onReorderFields: (fromIndex: number, toIndex: number) => void;
+    /**
+     * When provided, the component operates in list mode: it renders only an Accordion.Item
+     * (no Accordion root) and this value drives the open/closed state for validation tracking.
+     * The parent MetadataFieldList provides the shared Accordion root.
+     * When omitted, the component is standalone and manages its own Accordion root.
+     */
+    isExpanded?: boolean;
+    /**
+     * Called when the component wants to be expanded (e.g. when isFieldNew becomes true).
+     * Only meaningful in list mode (when isExpanded is provided).
+     */
+    onExpandedChange?: (expanded: boolean) => void;
+    /**
+     * An incrementing counter supplied by the parent form.
+     * Each time the value increases (e.g. on a failed submit), the configurator
+     * calls `touchAll()` so that all validation errors become visible immediately.
+     */
+    submitAttemptCount?: number;
+    /**
+     * Static taxonomy options (pre-fetched by the host). Use when you have already loaded
+     * the available taxonomies before rendering this component.
+     *
+     * Mutually exclusive with `fetchTaxonomies` — if both are provided, `fetchTaxonomies` takes precedence.
+     */
+    taxonomyOptions?: TaxonomyOption[];
+    /**
+     * Async function that resolves to the list of available taxonomy options.
+     *
+     * When provided, the shared feature calls this automatically the first time the user opens the
+     * taxonomy selector, then caches the result for the lifetime of the component. Loading and error
+     * states (including a retry button) are handled internally — the implementing team only needs to
+     * supply the fetch logic.
+     *
+     * Mutually exclusive with `taxonomyOptions`.
+     */
+    fetchTaxonomies?: () => Promise<TaxonomyOption[]>;
+    /**
+     * Domain-specific extensions to inject into this field's configurator panel.
+     *
+     * When provided, a tab switcher appears next to the context menu in the accordion header.
+     * The first tab always shows the built-in Edit UI; each additional tab renders the
+     * corresponding extension's content with the current field data passed as an argument.
+     *
+     * Switching tabs resets to the Edit tab whenever the accordion item is collapsed.
+     *
+     * Can also be injected at a higher level via `MetadataFieldList`, `MetadataTemplateEditorForm`,
+     * or `MetadataTemplateEditor` — the nearest provider in the tree wins.
+     */
+    fieldExtensions?: FieldConfiguratorExtension[];
+    /**
+     * Called whenever this field's internal validation state changes.
+     *
+     * Fires with `true` only after Yup has confirmed the field is valid. Until that
+     * async check finishes, the hook reports `false` (conservative for submit gating).
+     * After the first result, fires `false` when any validation error is detected.
+     *
+     * @example
+     * ```tsx
+     * const [isFieldValid, setIsFieldValid] = useState(true);
+     *
+     * <MetadataFieldConfigurator
+     *   values={values}
+     *   onValuesChange={setValues}
+     *   onValidationChange={setIsFieldValid}
+     *   // ...
+     * />
+     * <button disabled={!isFieldValid}>Save</button>
+     * ```
+     */
+    onValidationChange?: (isValid: boolean) => void;
+};
+/**
+ * A form-backed accordion item for configuring a single metadata field.
+ *
+ * Supports two operating modes:
+ * - **Standalone**: manages its own Accordion root and open/closed state internally.
+ * - **List mode**: when `isExpanded` is provided, the parent `MetadataFieldList` owns
+ *   the shared Accordion root and controls open/closed state.
+ *
+ * Drag-and-drop can be handled via native HTML5 events or dnd-kit (mutually exclusive).
+ *
+ * All state, effects, and callbacks live in {@link useFieldConfiguratorBehavior}.
+ * The edit form is rendered by {@link FieldEditContent}.
+ * The accordion header toolbar is rendered by {@link FieldActionSlot}.
+ *
+ * @example
+ * ```tsx
+ * // Standalone usage — host owns values state
+ * const [values, setValues] = useState<FieldData>(
+ *   createDefaultFieldValues(FieldType.Text),
+ * );
+ * const [isValid, setIsValid] = useState(false);
+ *
+ * <MetadataFieldConfigurator
+ *   index={0}
+ *   maxIndex={0}
+ *   values={values}
+ *   onValuesChange={setValues}
+ *   onValidationChange={setIsValid}
+ *   onDelete={key => console.log('deleted', key)}
+ *   onReorderFields={(from, to) => console.log('reorder', from, to)}
+ *   // Native HTML5 drag — swap for dndDragHandleProps when using dnd-kit
+ *   onDragStart={(e, i) => {}}
+ *   onDragEnd={(e, i) => {}}
+ *   onTouchStart={(e, i) => {}}
+ *   fetchTaxonomies={() => api.getTaxonomies()}
+ * />
+ * <button disabled={!isValid}>Save</button>
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With dnd-kit drag handle (e.g. inside a custom sortable list)
+ * const { attributes, listeners } = useSortable({ id: values.id });
+ *
+ * <MetadataFieldConfigurator
+ *   index={index}
+ *   maxIndex={maxIndex}
+ *   values={values}
+ *   onValuesChange={setValues}
+ *   onReorderFields={handleReorder}
+ *   dndDragHandleProps={{ listeners, attributes }}
+ * />
+ * ```
+ */
+export declare const MetadataFieldConfigurator: ({ index, maxIndex, values, onValuesChange, onDelete, onDuplicate, onReorderFields, onTouchStart, onDragStart, onDragEnd, externalErrors, externalTouched, dndDragHandleProps, isExpanded, onExpandedChange, taxonomyOptions, fetchTaxonomies, submitAttemptCount, fieldExtensions: fieldExtensionsProp, onValidationChange, }: MetadataFieldConfiguratorProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/lib/components/metadata-field-configurator/stories/story-fixtures.d.ts

@@ -0,0 +1,5 @@
+import { TaxonomyOption } from '../../../types';
+export declare const mockRegionTaxonomyOption: TaxonomyOption;
+export declare const mockDepartmentTaxonomyOption: TaxonomyOption;
+/** Region (selected) + Department — the standard two-taxonomy array used across interaction tests. */
+export declare const mockTaxonomyOptions: TaxonomyOption[];

package/dist/types/lib/components/metadata-field-configurator/utils.d.ts

@@ -0,0 +1,24 @@
+import { default as React } from 'react';
+import { FieldData, FieldType } from '../../types';
+/**
+ * Returns a fresh default `FieldData` object for the given field type.
+ *
+ * - A new object (and new option IDs) is produced on every call.
+ * - `dropdown.options` contains one empty entry only when `type` is `Dropdown`;
+ *   for all other types the array is empty.
+ */
+export declare function createDefaultFieldValues(type?: FieldType): FieldData;
+export declare const getConfigurationByType: (type: FieldType) => React.ReactElement | null;
+/**
+ * Returns true only when `errors` contains at least one leaf error whose
+ * exact path in `touched` is `true`.
+ *
+ * A shallow `touched[topLevelKey]` check is insufficient because lodash `set`
+ * creates intermediate objects (e.g. `{ dropdown: { options: [...] } }`) as
+ * soon as *any* nested field is touched, making the top-level key truthy even
+ * when the specific erroring field (e.g. a newly-added empty option) has never
+ * been interacted with.
+ */
+export declare function hasVisibleErrors(errors: unknown, touched: unknown): boolean;
+/** Recursively converts an object tree into a same-shape tree with all leaves set to `true`. */
+export declare function markAllTouched(obj: Record<string, unknown>): Record<string, unknown>;

package/dist/types/lib/components/metadata-field-list/index.d.ts

@@ -0,0 +1,2 @@
+export { MetadataFieldList, default as MetadataFieldListDefault } from './metadata-field-list';
+export type { MetadataFieldListProps, MetadataFieldListHandle } from './metadata-field-list';

package/dist/types/lib/components/metadata-field-list/metadata-field-list.d.ts

@@ -0,0 +1,109 @@
+import { MetadataFieldConfiguratorProps } from '../metadata-field-configurator';
+import { FieldConfiguratorExtension } from '../metadata-field-configurator/context/field-extensions-context';
+import { FieldData } from '../../types';
+/**
+ * Imperative handle exposed by `MetadataFieldList` via `forwardRef`.
+ * Use it to programmatically scroll to and expand a specific field.
+ */
+export type MetadataFieldListHandle = {
+    /** Expands the field with the given stable UI id and scrolls it into view. */
+    scrollToAndExpand: (fieldId: string) => void;
+};
+export type MetadataFieldListProps = {
+    /** The ordered list of field definitions to render. */
+    readonly fields: FieldData[];
+    /** Called whenever the field list changes (edits, reorders, deletions). */
+    readonly onChangeFields?: (fields: FieldData[]) => void;
+    /**
+     * Called with the zero-based index and the removed field after a deletion is confirmed.
+     * Use this for side effects only (e.g. an API delete call).
+     * Do NOT update the fields array here — `onChangeFields` already does that.
+     */
+    readonly onDeleteFieldAtIndex?: (index: number, field: FieldData) => void;
+    /** Called with the newly created duplicate field after it is inserted into the list. */
+    readonly onDuplicateField?: (field: FieldData) => void;
+    /**
+     * Static taxonomy options shared across all fields in the list.
+     * Use `fetchTaxonomies` instead for lazy loading with built-in loading/error/retry handling.
+     */
+    readonly taxonomyOptions?: MetadataFieldConfiguratorProps['taxonomyOptions'];
+    /**
+     * Async function called to fetch available taxonomy options.
+     * The list sets up a single shared `TaxonomyOptionsContext` for all its fields — the fetch
+     * fires once (on the first taxonomy selector open) and the result is cached for the lifetime
+     * of the list. Mutually exclusive with `taxonomyOptions`.
+     */
+    readonly fetchTaxonomies?: MetadataFieldConfiguratorProps['fetchTaxonomies'];
+    /**
+     * Zero-based index of the first field with validation errors.
+     * Combined with `submitAttemptCount` to re-trigger on repeated failed submits.
+     */
+    readonly firstInvalidFieldIndex?: number | null;
+    /**
+     * Mirrors Formik's `submitCount`. Each time this increments, the list scrolls
+     * to `firstInvalidFieldIndex` (if set) and marks all field errors as visible.
+     */
+    readonly submitAttemptCount?: number;
+    /**
+     * Domain-specific extensions injected into every field configurator in this list.
+     *
+     * Providing this prop wraps the list in a `FieldExtensionsContext.Provider`, making
+     * the extensions available to all `MetadataFieldConfigurator` instances without
+     * requiring per-field prop drilling.
+     *
+     * See `FieldConfiguratorExtension` for the shape of each extension.
+     */
+    readonly fieldExtensions?: FieldConfiguratorExtension[];
+    /**
+     * Called whenever the aggregate validity of all fields changes.
+     *
+     * Fires `false` as soon as any field fails its internal Yup validation, and `true`
+     * once every field in the list satisfies the schema again. An empty list is
+     * considered valid.
+     *
+     * Useful for gating a custom submit button without implementing field-level
+     * validation yourself.
+     *
+     * @example
+     * ```tsx
+     * const [allFieldsValid, setAllFieldsValid] = useState(true);
+     *
+     * <MetadataFieldList
+     *   fields={fields}
+     *   onChangeFields={setFields}
+     *   onValidationChange={setAllFieldsValid}
+     * />
+     * <button disabled={!allFieldsValid}>Save</button>
+     * ```
+     */
+    readonly onValidationChange?: (isValid: boolean) => void;
+};
+/**
+ * Renders an ordered, drag-and-drop list of metadata field configurators.
+ *
+ * Uses dnd-kit for pointer/touch/keyboard drag-and-drop reordering and a single
+ * shared Radix Accordion root so only one field is expanded at a time.
+ *
+ * @example
+ * ```tsx
+ * // Basic usage — onChangeFields handles all mutations including deletion
+ * <MetadataFieldList
+ *   fields={fields}
+ *   onChangeFields={setFields}
+ * />
+ *
+ * // With validation gating, lazy taxonomy loading, and an API delete side-effect
+ * const [allValid, setAllValid] = useState(true);
+ *
+ * <MetadataFieldList
+ *   fields={fields}
+ *   onChangeFields={setFields}
+ *   onDeleteFieldAtIndex={(index, field) => api.deleteField(field.key)}
+ *   onValidationChange={setAllValid}
+ *   fetchTaxonomies={() => api.getTaxonomies()}
+ * />
+ * <button disabled={!allValid}>Save</button>
+ * ```
+ */
+export declare const MetadataFieldList: import('react').ForwardRefExoticComponent<MetadataFieldListProps & import('react').RefAttributes<MetadataFieldListHandle>>;
+export default MetadataFieldList;

package/dist/types/lib/components/metadata-template-editor-form/metadata-template-editor-form.d.ts

@@ -0,0 +1,20 @@
+import { MetadataFieldListProps } from '../metadata-field-list';
+import { FieldConfiguratorExtension } from '../metadata-field-configurator/context/field-extensions-context';
+type MetadataTemplateEditorFormProps = {
+    formId?: string;
+    onCancel?: () => void;
+    taxonomyOptions?: MetadataFieldListProps['taxonomyOptions'];
+    fetchTaxonomies?: MetadataFieldListProps['fetchTaxonomies'];
+    hideActions?: boolean;
+    isEditMode?: boolean;
+    onDirtyStateChange?: (isDirty: boolean) => void;
+    onValidationChange?: (isValid: boolean) => void;
+    /**
+     * Domain-specific extensions injected into every field configurator.
+     * Wraps the form in a `FieldExtensionsContext.Provider` so all nested
+     * configurators can consume the extensions without per-field prop drilling.
+     */
+    fieldExtensions?: FieldConfiguratorExtension[];
+};
+declare const MetadataTemplateEditorForm: ({ formId, onCancel, taxonomyOptions, fetchTaxonomies, hideActions, isEditMode, onDirtyStateChange, onValidationChange, fieldExtensions, }: MetadataTemplateEditorFormProps) => import("react/jsx-runtime").JSX.Element;
+export default MetadataTemplateEditorForm;

package/dist/types/lib/components/metadata-template-editor-modal/index.d.ts

@@ -0,0 +1 @@
+export { MetadataTemplateEditorModal } from './metadata-template-editor-modal';

package/dist/types/lib/components/metadata-template-editor-modal/metadata-template-editor-modal.d.ts

@@ -0,0 +1,56 @@
+import { MetadataTemplateEditorProps } from '../../metadata-template-editor';
+export type MetadataTemplateEditorModalProps = MetadataTemplateEditorProps & {
+    /** Controls whether the modal is open. */
+    open: boolean;
+    /**
+     * Called when the modal requests an open-state change (close button, overlay click, Escape key).
+     * Use this to update the `open` prop in the parent.
+     */
+    onOpenChange: (open: boolean) => void;
+    /**
+     * Text displayed in the modal header.
+     * @default "New Metadata Template"
+     */
+    title?: string;
+};
+/**
+ * Modal wrapper around `MetadataTemplateEditor`.
+ *
+ * Renders the full template editor inside a Blueprint `Modal`, with Cancel and
+ * Save buttons promoted to the modal footer. The modal closes automatically
+ * after a successful submission or when the user cancels.
+ *
+ * The footer Save button is disabled while a submission is in progress. In **edit mode**
+ * it is additionally disabled until the user makes at least one change (`dirty`).
+ *
+ * The "unsaved changes" guard (dirty check + confirmation modal) is owned entirely
+ * by `MetadataTemplateEditor`. The modal delegates its footer Cancel and shell-close
+ * triggers to the editor via an imperative ref, so the guard logic and the
+ * `ConfirmationModal` live in exactly one place.
+ *
+ * @example
+ * ```tsx
+ * const [open, setOpen] = useState(false);
+ *
+ * // Create flow
+ * <MetadataTemplateEditorModal
+ *   open={open}
+ *   onOpenChange={setOpen}
+ *   onCreateTemplate={async body => { await api.createTemplate(body); }}
+ *   onSubmitError={err => logger.error('save failed', err)}
+ * />
+ *
+ * // Edit flow — dynamic title, error callback
+ * <MetadataTemplateEditorModal
+ *   mode={MetadataTemplateEditorMode.Edit}
+ *   open={open}
+ *   onOpenChange={setOpen}
+ *   fetchTemplate={useCallback(() => api.getTemplate(templateKey), [templateKey])}
+ *   onEditTemplate={async patches => { await api.updateTemplate(patches); }}
+ *   onSubmitError={err => logger.error('save failed', err)}
+ *   title="Edit Template"
+ * />
+ * ```
+ */
+export declare function MetadataTemplateEditorModal({ open, onOpenChange, onTemplateLoad, onValidationChange, onCancel, title, ...editorProps }: MetadataTemplateEditorModalProps): import("react/jsx-runtime").JSX.Element;
+export default MetadataTemplateEditorModal;

package/dist/types/lib/hooks/useMetadataTemplateFormSchema.d.ts

@@ -0,0 +1,17 @@
+import * as Yup from 'yup';
+export declare const useMetadataTemplateFormSchema: () => Yup.ObjectSchema<{
+    displayName: string;
+    templateKey: Yup.Maybe<string | undefined>;
+    fields: Yup.Maybe<{
+        description?: string | null | undefined;
+        name: string;
+        type: NonNullable<import('../types').FieldType | undefined>;
+        hidden: NonNullable<boolean | undefined>;
+    }[] | undefined>;
+    hidden: boolean | undefined;
+}, Yup.AnyObject, {
+    displayName: undefined;
+    templateKey: undefined;
+    fields: "";
+    hidden: undefined;
+}, "">;

package/dist/types/lib/hooks/useTemplateNameSchema.d.ts

@@ -0,0 +1,2 @@
+import * as Yup from 'yup';
+export declare const useTemplateNameSchema: () => Yup.StringSchema<string, Yup.AnyObject, undefined, "">;

package/dist/types/lib/index.d.ts

@@ -0,0 +1,7 @@
+export { MetadataTemplateEditor } from './metadata-template-editor';
+export type { MetadataTemplateEditorProps } from './metadata-template-editor';
+export { useMetadataTemplateFormSchema } from './hooks/useMetadataTemplateFormSchema';
+export { useTemplateNameSchema } from './hooks/useTemplateNameSchema';
+export { convertApiMetadataTemplateFieldToLocalConfiguratorField } from './utils/template-type-conversion/convertTemplateFieldToLocalConfigurator';
+export { mapFieldsWithUniqueKeys } from './utils/template-type-conversion/mapFieldsWithUniqueKeys';
+export { generateJSONPatchTemplateOperations } from './utils/template-type-conversion/generateJSONPatchTemplateOperations';

package/dist/types/lib/messages.d.ts

@@ -0,0 +1,143 @@
+declare const _default: {
+    createTitle: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    editTitle: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    templateName: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    templateNameDescription: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    cancel: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    save: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    fields: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    fieldsAddFirst: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    fieldsLearnMore: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    fieldRequired: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    forbiddenDisplayName: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    invalidCharacters: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    fieldNameTooLong: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    displayNameUsedBefore: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    submitting: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    closeAriaLabel: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    saveSuccessNotification: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    saveErrorNotification: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    notificationSuccessIconAriaLabel: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    notificationErrorIconAriaLabel: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    notificationCloseButtonAriaLabel: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    loading: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    fetchError: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    reload: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    unsavedChangesTitle: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    unsavedChangesBody: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    unsavedChangesDiscard: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    unsavedChangesKeepEditing: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+};
+export default _default;