@box/metadata-template-editor 1.19.0

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

@@ -0,0 +1,17 @@
+/** Reflects the selection state of a Chip, surfaced as a `data-state` attribute for styling. */
+export declare enum ChipState {
+    Selected = "selected",
+    Unselected = "unselected"
+}
+type ChipProps = {
+    /** Text content displayed inside the chip. */
+    value: string;
+    /** Whether this chip represents a selected taxonomy level. Defaults to `false`. */
+    selected?: boolean;
+};
+/**
+ * A small inline label used inside `LevelsChain` to represent a single taxonomy level.
+ * Applies selected/unselected visual styles and exposes an accessible aria-label.
+ */
+export declare const Chip: ({ value, selected }: ChipProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1 @@
+export { LevelsChain } from './levels-chain';

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

@@ -0,0 +1,31 @@
+import { TaxonomyLevel } from '../../../../types';
+interface LevelsChainProps {
+    /** The full ordered list of taxonomy levels to display. Defaults to `[]`. */
+    levels?: TaxonomyLevel[];
+    /** The `.level` values of the currently selected levels. */
+    selectedLevels: number[];
+}
+/**
+ * Renders a chain of levels, splitting them into two halves and managing their visibility
+ * based on the available container width. Levels that do not fit within the container are hidden
+ * and represented by a counter chip in the middle.
+ *
+ * The `selected` state of each level is determined by checking if its `.level` property exists in the `selectedLevels` array.
+ *
+ * @param {LevelsChainProps} props - The props for the LevelsChain component.
+ * @param {TaxonomyLevel[]} [props.levels=[]] - The array of levels to be displayed.
+ * @param {number[]} props.selectedLevels - The level numbers of the selected levels.
+ *
+ * @returns {JSX.Element} The rendered LevelsChain component.
+ *
+ * @example
+ * // Example usage of LevelsChain component
+ * <LevelsChain levels={[{ name: 'Level 1', level: 1 }, { name: 'Level 2', level: 2 }]} selectedLevels={[1]} />
+ *
+ * @remarks
+ * - The component measures the widths of the levels and dynamically hides levels that do not fit within the container.
+ * - The hidden levels are represented by a counter chip in the middle of the chain.
+ * - The component re-measures the container width on window resize.
+ */
+export declare const LevelsChain: ({ levels, selectedLevels }: LevelsChainProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,10 @@
+interface HideCountsInputs {
+    isMeasured: boolean;
+    leftLevelWidths: number[];
+    rightLevelWidths: number[];
+    containerWidthPx: number;
+    buttonWidthPx: number;
+    gapBetweenItems: number;
+}
+export declare const getHideCounts: ({ isMeasured, leftLevelWidths, rightLevelWidths, containerWidthPx, buttonWidthPx, gapBetweenItems, }: HideCountsInputs) => [number, number];
+export {};

package/dist/types/lib/components/metadata-field-configurator/components/type-specific-configuration/dropdown/__mocks__/getInitialValues.d.ts

@@ -0,0 +1,2 @@
+import { FieldData } from '../../../../../../types';
+export declare const getInitialValues: () => FieldData;

package/dist/types/lib/components/metadata-field-configurator/components/type-specific-configuration/dropdown/dropdown-default-values.d.ts

@@ -0,0 +1,2 @@
+import { DropdownField } from '../../../../../types';
+export declare const getDropdownDefaultValues: () => DropdownField;

package/dist/types/lib/components/metadata-field-configurator/components/type-specific-configuration/dropdown/dropdown-field-configuration.d.ts

@@ -0,0 +1 @@
+export declare const DropdownFieldConfiguration: () => import("react/jsx-runtime").JSX.Element;

package/dist/types/lib/components/metadata-field-configurator/components/type-specific-configuration/dropdown/sortable-option-list.d.ts

@@ -0,0 +1,6 @@
+type SortableOptionListProps = {
+    readonly shouldFocusLastOption: boolean;
+    readonly onFocusConsumed: () => void;
+};
+export declare function SortableOptionList({ shouldFocusLastOption, onFocusConsumed }: SortableOptionListProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/lib/components/metadata-field-configurator/components/type-specific-configuration/index.d.ts

@@ -0,0 +1,2 @@
+export { DropdownFieldConfiguration } from './dropdown/dropdown-field-configuration';
+export { TaxonomyFieldConfiguration } from './taxonomy/taxonomy-field-configuration';

package/dist/types/lib/components/metadata-field-configurator/components/type-specific-configuration/taxonomy/taxonomy-default-values.d.ts

@@ -0,0 +1,2 @@
+import { TaxonomyField } from '../../../../../types';
+export declare const taxonomyDefaultValues: TaxonomyField;

package/dist/types/lib/components/metadata-field-configurator/components/type-specific-configuration/taxonomy/taxonomy-field-configuration.d.ts

@@ -0,0 +1 @@
+export declare const TaxonomyFieldConfiguration: () => import("react/jsx-runtime").JSX.Element;

package/dist/types/lib/components/metadata-field-configurator/components/type-specific-configuration/taxonomy/taxonomy-field-configurator-initial-state.d.ts

@@ -0,0 +1 @@
+export declare const TaxonomyFieldConfiguratorInitialState: () => import("react/jsx-runtime").JSX.Element;

package/dist/types/lib/components/metadata-field-configurator/components/type-specific-configuration/taxonomy/taxonomy-selector-messages.d.ts

@@ -0,0 +1,43 @@
+declare const _default: {
+    taxonomySelectorAriaLabel: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    taxonomySelector: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    recentlyUsedTaxonomies: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    allTaxonomies: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    searchTaxonomiesInputPlaceholder: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    loadingTaxonomies: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    loadTaxonomiesError: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    retryLoadTaxonomies: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+};
+export default _default;

package/dist/types/lib/components/metadata-field-configurator/components/type-specific-configuration/taxonomy/taxonomy-selector.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+import { TaxonomyOption } from '../../../../../types';
+type TaxonomySelectorProps = {
+    data: TaxonomyOption[];
+    onClick: (option: TaxonomyOption) => void;
+    onSearchValue: (value: string) => void;
+    triggerButton?: React.ReactNode;
+    disabled?: boolean;
+    resetValueOnHide?: boolean;
+};
+export declare const TaxonomySelector: ({ data, onClick, onSearchValue, triggerButton, disabled, resetValueOnHide, }: TaxonomySelectorProps) => React.ReactElement;
+export {};

package/dist/types/lib/components/metadata-field-configurator/components/type-specific-configuration/taxonomy/useTaxonomySelect.d.ts

@@ -0,0 +1,5 @@
+import { FieldConfiguratorContextValue } from '../../../context/field-configurator-context';
+import { TaxonomyOption } from '../../../../../types';
+export declare const useTaxonomySelect: (ctx: Pick<FieldConfiguratorContextValue, "values" | "setFieldValue">) => {
+    onTaxonomySelect: (option: TaxonomyOption) => void;
+};

package/dist/types/lib/components/metadata-field-configurator/components/type-specific-configuration/taxonomy/utils.d.ts

@@ -0,0 +1,2 @@
+import { TaxonomyOption } from '../../../../../types';
+export declare const filterTaxonomiesByValue: (taxonomies: TaxonomyOption[], value: string) => TaxonomyOption[];

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

@@ -0,0 +1,57 @@
+import { default as React } from 'react';
+import { FieldData, BasicField } from '../../../types';
+/**
+ * Form-library-agnostic interface for field configurator state and mutations.
+ * Sub-components consume this via {@link useFieldConfigurator} instead of
+ * coupling to any specific form library.
+ *
+ * The context is provided by {@link MetadataFieldConfigurator},
+ * which bridges parent-owned controlled state into these callbacks.
+ * In stories/tests, {@link FieldConfiguratorProvider} offers a self-contained
+ * alternative with its own internal state.
+ */
+export interface FieldConfiguratorContextValue {
+    /** Current field data (name, type, dropdown options, taxonomy config, etc.). */
+    values: FieldData;
+    /** Validation errors keyed by field path (e.g. `{ name: "Required" }`). */
+    errors: Record<string, unknown>;
+    /** Tracks which fields have been interacted with, keyed by field path. */
+    touched: Record<string, unknown>;
+    /** Whether the current field data passes validation. */
+    isValid: boolean;
+    /** Set a top-level field value by key. Enforces that the value matches the field's type. */
+    setFieldValue<K extends keyof BasicField>(field: K, value: BasicField[K]): void;
+    /** Replace the entire values object. */
+    setValues(values: FieldData): void;
+    /** Mark a single field as touched by dot-path. */
+    setFieldTouched(field: string, isTouched?: boolean): void;
+    /** Replace the entire touched map. */
+    setTouched(touched: Record<string, unknown>): void;
+    /** onChange handler for native `<input>` elements. Reads `name` from `e.target` as a dot-path. */
+    handleChange(e: React.ChangeEvent<HTMLInputElement>): void;
+    /** onBlur handler that marks the blurred field as touched via `e.target.name`. */
+    handleBlur(e: React.FocusEvent<unknown>): void;
+    /** Trigger validation. The parent decides the validation strategy. */
+    validateForm(): Promise<void>;
+}
+export declare const FieldConfiguratorContext: React.Context<FieldConfiguratorContextValue | null>;
+/**
+ * Returns the nearest {@link FieldConfiguratorContextValue}.
+ * Must be called inside a `<FieldConfiguratorContext.Provider>` (production)
+ * or `<FieldConfiguratorProvider>` (stories/tests).
+ */
+export declare function useFieldConfigurator(): FieldConfiguratorContextValue;
+/**
+ * Self-contained provider that manages form state internally.
+ * Intended for stories, tests, and standalone sub-component usage
+ * where no external form library drives the state.
+ *
+ * `initialErrors` and `initialTouched` let stories pre-seed validation state
+ * so error UI can be displayed on first paint without running the full validation schema.
+ */
+export declare const FieldConfiguratorProvider: React.FC<{
+    initialValues: FieldData;
+    initialErrors?: Record<string, unknown>;
+    initialTouched?: Record<string, unknown>;
+    children: React.ReactNode;
+}>;

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

@@ -0,0 +1,52 @@
+import { FunctionComponent, PropsWithChildren, SVGProps } from 'react';
+import { FieldData } from '../../../types';
+/**
+ * A single domain-specific extension that can be injected into a field configurator.
+ *
+ * When one or more extensions are provided, the field configurator gains a tab switcher
+ * in its header action area. The first tab always shows the built-in Edit UI; subsequent
+ * tabs render the extension's content panel with the current field data.
+ *
+ * @example
+ * ```tsx
+ * const myExtension: FieldConfiguratorExtension = {
+ *   icon: MyCustomIcon,
+ *   label: 'My settings',
+ *   renderContent: field => <MyFieldSettings field={field} />,
+ * };
+ *
+ * <MetadataFieldList fields={fields} fieldExtensions={[myExtension]} />
+ * ```
+ */
+export interface FieldConfiguratorExtension {
+    /**
+     * Icon displayed as the tab trigger button.
+     * Use the same SVG icon component format as the rest of the blueprint-web icon system.
+     */
+    icon: FunctionComponent<PropsWithChildren<SVGProps<SVGSVGElement>>>;
+    /**
+     * Accessible label for the tab trigger button (used as `aria-label`).
+     */
+    label: string;
+    /**
+     * Renders the extension's content panel.
+     * Receives the current field's data snapshot — read-only.
+     * To mutate the field, consume `useFieldConfigurator()` from within the rendered subtree.
+     */
+    renderContent: (field: FieldData) => React.ReactNode;
+}
+/**
+ * Provides the list of field configurator extensions to the subtree.
+ * Consumed by `MetadataFieldConfigurator` via `useFieldExtensions()`.
+ *
+ * Any component in the tree (`MetadataTemplateEditor`, `MetadataTemplateEditorForm`,
+ * `MetadataFieldList`, `MetadataFieldConfigurator`) can be the provider — the nearest
+ * one wins. When no provider is present, the default empty array is used and the
+ * configurator renders its standard Edit UI without any tabs.
+ */
+export declare const FieldExtensionsContext: import('react').Context<FieldConfiguratorExtension[]>;
+/**
+ * Returns the nearest list of field configurator extensions.
+ * Returns an empty array when no `FieldExtensionsContext.Provider` is present.
+ */
+export declare function useFieldExtensions(): FieldConfiguratorExtension[];

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

@@ -0,0 +1,21 @@
+import { TaxonomyOption } from '../../../types';
+export type TaxonomyFetchStatus = 'idle' | 'loading' | 'success' | 'error';
+export type TaxonomyContextValue = {
+    /** Currently available taxonomy options. Empty while loading. */
+    options: TaxonomyOption[];
+    /** Fetch lifecycle state. `'idle'` before first open, `'success'` once loaded. */
+    status: TaxonomyFetchStatus;
+    /**
+     * Called when the taxonomy selector popover opens.
+     * Triggers a lazy fetch (if `fetchTaxonomies` was provided) or is a no-op for static options.
+     * On error, calling this again retries the fetch.
+     */
+    onSelectorOpen: () => void;
+};
+export declare const TaxonomyOptionsContext: import('react').Context<TaxonomyContextValue>;
+export declare function useTaxonomyOptions(): TaxonomyContextValue;
+/**
+ * Creates a static (pre-fetched) taxonomy context value.
+ * Use in stories, tests, or when you already have the options available.
+ */
+export declare function createStaticTaxonomyContext(options: TaxonomyOption[]): TaxonomyContextValue;

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

@@ -0,0 +1,57 @@
+import { FieldConfiguratorExtension } from '../context/field-extensions-context';
+import { FieldConfiguratorContextValue } from '../context/field-configurator-context';
+import { TaxonomyContextValue } from '../context/taxonomy-options-context';
+import { FieldData, TaxonomyOption } from '../../../types';
+export type UseFieldConfiguratorBehaviorParams = {
+    values: FieldData;
+    onValuesChange: (values: FieldData) => void;
+    onDelete?: (key: string) => void;
+    isExpanded?: boolean;
+    onExpandedChange?: (expanded: boolean) => void;
+    submitAttemptCount?: number;
+    taxonomyOptions?: TaxonomyOption[];
+    fetchTaxonomies?: () => Promise<TaxonomyOption[]>;
+    fieldExtensionsProp?: FieldConfiguratorExtension[];
+    onValidationChange?: (isValid: boolean) => void;
+};
+export type FieldConfiguratorBehavior = {
+    /** Value for `FieldConfiguratorContext.Provider`. */
+    contextValue: FieldConfiguratorContextValue;
+    /** Value for `TaxonomyOptionsContext.Provider` (only used in standalone mode). */
+    taxonomyContextValue: TaxonomyContextValue;
+    /** Resolved extension list (prop wins over context). */
+    extensions: FieldConfiguratorExtension[];
+    /** Whether the accordion item is currently open. */
+    isActive: boolean;
+    /** Change handler for the standalone Accordion root's `onValueChange`. */
+    handleAccordionValueChange: (value: string) => void;
+    isDeleteConfirmationModalOpen: boolean;
+    openConfirmationModal: () => void;
+    closeConfirmationModal: () => void;
+    handleDeleteField: () => void;
+    /** Controlled tab ID for the ContentSwitcher (`'edit'` | `'ext-N'`). */
+    activeTabId: string;
+    setActiveTabId: (id: string) => void;
+    /** The active extension, or `null` when the Edit tab is selected. */
+    activeExtension: FieldConfiguratorExtension | null;
+    isTypeEditable: boolean;
+    /** Stable client-side ID used as the Accordion item value and DOM ID prefix. */
+    uniqueKey: string;
+    nameInputId: string;
+    descriptionInputId: string;
+    accordionTitle: string;
+    TitleIcon: (props: React.SVGProps<SVGSVGElement>) => React.JSX.Element;
+    /** Whether there are visible (touched) validation errors on the field. */
+    hasErrors: boolean;
+    /** Called when the user picks a new field type from the Select. */
+    handleTypeChange: (fieldType: FieldData['type']) => void;
+    /** Called by FieldContextMenu when the user toggles field visibility. */
+    handleChangeVisibility: (hidden: boolean) => void;
+};
+/**
+ * Encapsulates all state, effects, and callbacks for `MetadataFieldConfigurator`.
+ *
+ * Separated from the rendering layer so the component file stays focused on
+ * structure and the hook can be read, tested, and reasoned about in isolation.
+ */
+export declare function useFieldConfiguratorBehavior({ values, onValuesChange, onDelete, isExpanded, onExpandedChange, submitAttemptCount, taxonomyOptions, fetchTaxonomies, fieldExtensionsProp, onValidationChange, }: UseFieldConfiguratorBehaviorParams): FieldConfiguratorBehavior;

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

@@ -0,0 +1,27 @@
+import { FocusEvent } from 'react';
+import { FieldData } from '../../../types';
+export type FieldValidationResult = {
+    errors: Record<string, unknown>;
+    touched: Record<string, unknown>;
+    isValid: boolean;
+    /** Trigger validation against the current values. */
+    validateForm: () => Promise<void>;
+    /**
+     * Marks every leaf in the current values tree as touched.
+     * Call this on collapse to surface all pending errors immediately.
+     */
+    touchAll: () => void;
+    /** Mark a single field path as touched. */
+    setFieldTouched: (field: string, isTouched?: boolean) => void;
+    /** Replace the entire touched map. */
+    setTouched: (touched: Record<string, unknown>) => void;
+    /** onBlur handler that marks the blurred field as touched via `e.target.name`. */
+    handleBlur: (e: FocusEvent<unknown>) => void;
+};
+/**
+ * Runs the metadata field Yup schema against `values` and keeps
+ * `errors` / `isValid` / `touched` in sync.
+ *
+ * Used internally by `MetadataFieldConfigurator` — not intended for direct use.
+ */
+export declare function useFieldValidation(values: FieldData): FieldValidationResult;

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

@@ -0,0 +1,19 @@
+import { TaxonomyOption } from '../../../types';
+import { TaxonomyContextValue } from '../context/taxonomy-options-context';
+/**
+ * Manages lazy, on-demand fetching of taxonomy options for use with `TaxonomyOptionsContext`.
+ *
+ * When `fetchTaxonomies` is not provided, returns a static no-fetch context (status `'success'`,
+ * empty options, no-op `onSelectorOpen`) so the taxonomy selector renders normally with whatever
+ * options were pre-supplied via the `taxonomyOptions` prop.
+ *
+ * When `fetchTaxonomies` is provided:
+ * - Fetch is deferred until `onSelectorOpen` is called (i.e. the popover opens).
+ * - Results are cached: a successful fetch is never repeated on subsequent opens.
+ * - On error, calling `onSelectorOpen` again (via the retry button) restarts the fetch.
+ *
+ * @param fetchTaxonomies - An async function that resolves to an array of taxonomy options.
+ *   The function is called by the shared feature — consumers do not need to manage loading state.
+ * @param staticOptions - Fallback options used when `fetchTaxonomies` is not provided.
+ */
+export declare function useTaxonomyFetch(fetchTaxonomies?: () => Promise<TaxonomyOption[]>, staticOptions?: TaxonomyOption[]): TaxonomyContextValue;

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

@@ -0,0 +1,15 @@
+import { FieldType } from '../../../types';
+import * as Yup from 'yup';
+/**
+ * Returns a memoized Yup validation schema for a metadata template field.
+ *
+ * The schema is lazily evaluated so that type-specific rules (dropdown options,
+ * taxonomy configuration) are only applied when the field type matches.
+ * Error messages are localised via `react-intl`.
+ */
+export declare const useTemplateFieldSchema: () => Yup.Lazy<{
+    description?: string | null | undefined;
+    name: string;
+    type: NonNullable<FieldType | undefined>;
+    hidden: NonNullable<boolean | undefined>;
+}, Yup.AnyObject, any>;

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

@@ -0,0 +1,6 @@
+export { useTemplateFieldSchema } from './hooks/useTemplateFieldSchema';
+export { MetadataFieldConfigurator, } from './metadata-field-configurator';
+export type { GeneralComponentProps, MetadataFieldConfiguratorProps } from './metadata-field-configurator';
+export { createDefaultFieldValues } from './utils';
+export { FieldExtensionsContext, useFieldExtensions } from './context/field-extensions-context';
+export type { FieldConfiguratorExtension } from './context/field-extensions-context';

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

@@ -0,0 +1,164 @@
+export declare const general: {
+    fieldTypeLabel: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    fieldTypePlaceholder: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    fieldNameLabel: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    fieldNameInputPlaceholder: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    fieldDescriptionLabel: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    fieldDescriptionInputPlaceholder: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    descriptionInfoTooltip: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    descriptionLearnMoreBadgeAriaLabel: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    dragAndDropFieldAriaLabel: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    hideField: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    showField: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    hiddenStatus: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    deleteFieldTitle: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    deleteFieldDescription: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    cancelDeleteField: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    confirmDeleteField: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    moveUp: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    moveUpAriaLabel: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    moveDown: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    moveDownAriaLabel: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    deleteField: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    deleteFieldAriaLabel: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    contextMenuAriaLabel: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    editTabAriaLabel: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    duplicateField: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    duplicateFieldAriaLabel: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+};
+export declare const validationErrors: {
+    fieldNameCannotBeEmpty: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    fieldNameTooLong: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    duplicateOption: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    optionKeyCannotBeEmpty: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    selectedLevelRequired: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    thisFieldContainsErrors: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+};

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

@@ -0,0 +1,43 @@
+declare const _default: {
+    addOption: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    deleteDropdownOptionAriaLabel: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    dragAndDropOptionAriaLabel: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    allowMultipleSelection: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    addAnOptionOptionPlaceholder: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    deleteOptionTitle: {
+        id: string;
+        description: string;
+        defaultMessage: string;
+    };
+    deleteOptionDescription: {
+        id: string;
+        description: string;
+        defaultMessage: string;
+    };
+    optionListValidationError: {
+        id: string;
+        description: string;
+        defaultMessage: string;
+    };
+};
+export default _default;

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

@@ -0,0 +1,18 @@
+declare const _default: {
+    noLevels: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    chipSelected: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    chipNotSelected: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+};
+export default _default;