@box/metadata-template-editor 1.19.0

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

@@ -0,0 +1,290 @@
+import { MetadataTemplateCreateBody, MetadataTemplateEditorMode, MetadataTemplatePatchItem, MetadataTemplateApiResponse } from './types';
+import { MetadataFieldListProps } from './components/metadata-field-list';
+import { FieldConfiguratorExtension } from './components/metadata-field-configurator/context/field-extensions-context';
+type MetadataTemplateEditorCommonProps = {
+    /** Called when the user dismisses the form without saving. */
+    onCancel?: () => void;
+    /**
+     * Fired whenever the form's dirty state changes.
+     * Useful for parent components (e.g. a modal footer) that need to reflect
+     * whether the user has made any unsaved changes.
+     *
+     * @example
+     * ```tsx
+     * const [hasUnsavedChanges, setHasUnsavedChanges] = useState(false);
+     *
+     * <MetadataTemplateEditor
+     *   onDirtyStateChange={setHasUnsavedChanges}
+     *   // ...
+     * />
+     * {hasUnsavedChanges && <Banner>You have unsaved changes.</Banner>}
+     * ```
+     */
+    onDirtyStateChange?: (isDirty: boolean) => void;
+    /**
+     * Called when the API save fails — i.e. when `onCreateTemplate` or `onEditTemplate`
+     * throws.
+     *
+     * The editor catches that error to show its own error notification and then
+     * re-throws into Formik (which only uses it to clear `isSubmitting`). Because
+     * Formik swallows the re-throw, there is no way to observe the error outside
+     * the editor _unless_ this callback is provided.
+     *
+     * Use it to update external state, log to analytics, or trigger UI outside
+     * the editor without having to wrap your own callback with try-catch.
+     *
+     * @example
+     * ```tsx
+     * <MetadataTemplateEditor
+     *   onCreateTemplate={async body => { await api.createTemplate(body); }}
+     *   onSubmitError={err => analytics.track('template_save_failed', { err })}
+     * />
+     * ```
+     */
+    onSubmitError?: (error: unknown) => void;
+    /**
+     * Fired whenever the form-level validation state changes.
+     *
+     * Receives `true` when all fields and the template name satisfy the Yup schema,
+     * and `false` once any validation error is present. The editor enables Formik's
+     * `validateOnMount`, so the first validation pass runs after the form mounts (Yup
+     * is asynchronous — there can be a short window before the first callback).
+     *
+     * Most useful when `hideActions={true}` and the host renders its own submit button
+     * outside the form — the host can gate that button on this value.
+     *
+     * @example
+     * ```tsx
+     * const [isFormValid, setIsFormValid] = useState(true);
+     *
+     * <MetadataTemplateEditor
+     *   hideActions
+     *   formId="my-form"
+     *   onValidationChange={setIsFormValid}
+     *   // ...
+     * />
+     * <button form="my-form" type="submit" disabled={!isFormValid}>Save</button>
+     * ```
+     */
+    onValidationChange?: (isValid: boolean) => void;
+    /**
+     * Fired once the template data has been fetched and the form is populated.
+     * Only called in edit mode.
+     *
+     * @example
+     * ```tsx
+     * // Reflect the loaded template name in a parent heading
+     * const [templateName, setTemplateName] = useState('');
+     *
+     * <h2>{templateName || 'Loading…'}</h2>
+     * <MetadataTemplateEditor
+     *   mode={MetadataTemplateEditorMode.Edit}
+     *   fetchTemplate={() => api.getTemplate(templateKey)}
+     *   onEditTemplate={handleEdit}
+     *   onTemplateLoad={t => setTemplateName(t.displayName)}
+     * />
+     * ```
+     */
+    onTemplateLoad?: (template: MetadataTemplateApiResponse) => void;
+    /**
+     * Static taxonomy options forwarded to each field configurator.
+     * Use `fetchTaxonomies` instead for lazy loading with built-in loading/error/retry handling.
+     */
+    taxonomyOptions?: MetadataFieldListProps['taxonomyOptions'];
+    /**
+     * Async function called to fetch the available taxonomy options.
+     *
+     * The shared feature calls this automatically the first time the user opens the taxonomy selector
+     * on any field. Results are cached per-field for the lifetime of the component — the implementing
+     * team does not need to manage loading state, error handling, or retry logic.
+     *
+     * Mutually exclusive with `taxonomyOptions`.
+     *
+     * @example
+     * ```tsx
+     * <MetadataTemplateEditor
+     *   fetchTaxonomies={() => api.getTaxonomies(namespaceId)}
+     *   onCreateTemplate={handleCreate}
+     * />
+     * ```
+     */
+    fetchTaxonomies?: MetadataFieldListProps['fetchTaxonomies'];
+    /**
+     * HTML `id` applied to the `<form>` element.
+     * Useful when submit/cancel buttons are rendered outside the form DOM subtree
+     * (e.g. inside a modal footer) and need to be associated via the `form` attribute.
+     */
+    formId?: string;
+    /**
+     * When `true`, the built-in Cancel / Save action bar is not rendered.
+     * Use this together with `formId` when the parent (e.g. a modal) owns the actions.
+     */
+    hideActions?: boolean;
+    /**
+     * Domain-specific extensions injected into every field configurator in this editor.
+     *
+     * When provided, a tab switcher appears in each field's accordion header next to the
+     * context menu. The first tab always shows the built-in Edit UI; each additional tab
+     * renders the corresponding extension's content with the current field data.
+     *
+     * Can also be passed at a lower level via `MetadataFieldList` or `MetadataFieldConfigurator`
+     * directly — the nearest provider in the tree wins.
+     *
+     * @example
+     * ```tsx
+     * <MetadataTemplateEditor
+     *   mode="edit"
+     *   fieldExtensions={[
+     *     {
+     *       icon: MyIcon,
+     *       label: 'My settings',
+     *       renderContent: field => <MyFieldPanel field={field} />,
+     *     },
+     *   ]}
+     * />
+     * ```
+     */
+    fieldExtensions?: FieldConfiguratorExtension[];
+};
+/**
+ * Create mode: no pre-existing values.
+ */
+type CreateModeProps = {
+    /** Discriminates the union; must be `MetadataTemplateEditorMode.Create` for the create flow. */
+    mode: MetadataTemplateEditorMode.Create;
+    /**
+     * The namespace the new template will be created in.
+     * Included verbatim in the create request body — the editor does not render
+     * it as a visible field.
+     *
+     * @example `"enterprise"` · `"global"` · `"myOrg"`
+     */
+    namespace: string;
+    /**
+     * Called when the user saves a **new** template and the form passes all validation.
+     * Receives the API-ready create payload with fields converted from the internal
+     * configurator shape. `await` this if you need `isSubmitting` to remain `true`
+     * during the API call.
+     */
+    onCreateTemplate: (body: MetadataTemplateCreateBody) => Promise<void> | void;
+    onEditTemplate?: never;
+    fetchTemplate?: never;
+};
+/**
+ * Edit mode: the form fetches its own data and the Save button is only enabled
+ * when there are unsaved changes (`formik.dirty`).
+ */
+type EditModeProps = {
+    /** Discriminates the union; must be `MetadataTemplateEditorMode.Edit` for the edit flow. */
+    mode: MetadataTemplateEditorMode.Edit;
+    /**
+     * Called when the user saves changes to an **existing** template and the form
+     * passes all validation. Receives the array of JSON Patch operations that
+     * describe only the changes made since the template was loaded.
+     * `await` this if you need `isSubmitting` to remain `true` during the API call.
+     */
+    onEditTemplate: (patchItems: MetadataTemplatePatchItem[]) => Promise<void> | void;
+    onCreateTemplate?: never;
+    /**
+     * Called once (and re-called whenever the reference changes) to fetch the
+     * existing template data. The editor handles loading state and field conversion
+     * internally — the host does not need to manage either.
+     *
+     * Provide a stable reference (e.g. via `useCallback`) to avoid unnecessary
+     * re-fetches; a new reference triggers a fresh fetch.
+     */
+    fetchTemplate: () => Promise<MetadataTemplateApiResponse>;
+    /** Namespace is read from the fetched template in edit mode — do not pass it from the host. */
+    namespace?: never;
+};
+export type MetadataTemplateEditorProps = MetadataTemplateEditorCommonProps & (CreateModeProps | EditModeProps);
+/**
+ * Imperative handle exposed by `MetadataTemplateEditor` via `ref`.
+ *
+ * Allows a parent (e.g. `MetadataTemplateEditorModal`) to delegate its own
+ * cancel / close triggers to the editor so that the "unsaved changes" guard
+ * and the `ConfirmationModal` live in exactly one place.
+ *
+ * @example
+ * ```tsx
+ * const editorRef = useRef<MetadataTemplateEditorHandle>(null);
+ *
+ * // Delegate the modal's footer Cancel and shell close to the editor:
+ * <MetadataTemplateEditorModal … />  // internally calls editorRef.current.requestClose()
+ *
+ * // Or wire it up manually:
+ * <button onClick={() => editorRef.current?.requestClose()}>Cancel</button>
+ * <MetadataTemplateEditor ref={editorRef} … />
+ * ```
+ */
+export type MetadataTemplateEditorHandle = {
+    /**
+     * Triggers the editor's cancel flow from outside the component.
+     * If the form is dirty, opens the "unsaved changes" confirmation modal.
+     * Otherwise calls `onCancel` immediately.
+     */
+    requestClose: () => void;
+};
+/**
+ * Full metadata template creation / editing form.
+ *
+ * - Formik owns `displayName`, `templateKey`, and the `fields` array.
+ * - Each `MetadataFieldConfigurator` (rendered via `MetadataFieldList`) runs
+ *   its own internal Yup validation for real-time feedback — no error threading
+ *   is required from this form down to the fields.
+ * - `useMetadataTemplateFormSchema` embeds the same per-field schema here so Formik
+ *   can gate submission if any field is invalid, even if the user hasn't interacted
+ *   with it yet.
+ * - Empty state shows `FieldTypeTiles`; once fields exist, shows `MetadataFieldList`
+ *   with a `FieldTypeDropdown` "Add field" button below.
+ * - Pass `mode={MetadataTemplateEditorMode.Edit}` to enable **edit mode**: the form
+ *   fetches its own data via `fetchTemplate` and the Save button is only enabled when
+ *   there are unsaved changes.
+ *
+ * @example
+ * ```tsx
+ * // Minimal create flow
+ * <MetadataTemplateEditor
+ *   mode={MetadataTemplateEditorMode.Create}
+ *   namespace="enterprise"
+ *   onCreateTemplate={async body => { await api.createTemplate(body); }}
+ *   onCancel={() => navigate(-1)}
+ * />
+ *
+ * // Minimal edit flow
+ * <MetadataTemplateEditor
+ *   mode={MetadataTemplateEditorMode.Edit}
+ *   fetchTemplate={useCallback(() => api.getTemplate(templateKey), [templateKey])}
+ *   onEditTemplate={async patches => { await api.updateTemplate(patches); }}
+ *   onCancel={() => navigate(-1)}
+ * />
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // External submit button with full observer callbacks
+ * const [isFormValid, setIsFormValid] = useState(true);
+ * const [isDirty, setIsDirty] = useState(false);
+ *
+ * <MetadataTemplateEditor
+ *   mode={MetadataTemplateEditorMode.Edit}
+ *   fetchTemplate={() => api.getTemplate(templateKey)}
+ *   onEditTemplate={async patches => { await api.updateTemplate(patches); }}
+ *   onTemplateLoad={t => setPageTitle(t.displayName)}
+ *   onDirtyStateChange={setIsDirty}
+ *   onValidationChange={setIsFormValid}
+ *   onSubmitError={err => logger.error('save failed', err)}
+ *   hideActions
+ *   formId="template-form"
+ * />
+ * <button
+ *   form="template-form"
+ *   type="submit"
+ *   disabled={!isFormValid || !isDirty}
+ * >
+ *   Save
+ * </button>
+ * ```
+ */
+export declare const MetadataTemplateEditor: import('react').ForwardRefExoticComponent<MetadataTemplateEditorProps & import('react').RefAttributes<MetadataTemplateEditorHandle>>;
+export default MetadataTemplateEditor;

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

@@ -0,0 +1,311 @@
+/**
+ * Discriminates between creating a new template and editing an existing one.
+ * Pass as the `mode` prop on `MetadataTemplateEditor` / `MetadataTemplateEditorModal`.
+ */
+export declare enum MetadataTemplateEditorMode {
+    Create = "create",
+    Edit = "edit"
+}
+/**
+ * Types of fields that can be defined in a metadata template:
+ * - Text - plain text field
+ * - Number - numeric field
+ * - Date - date field
+ * - Dropdown - field with a dropdown list
+ * - Taxonomy - taxonomy field (e.g. key-value pairs)
+ */
+export declare enum FieldType {
+    Text = "text",
+    Number = "number",
+    Date = "date",
+    Dropdown = "dropdown",
+    Taxonomy = "taxonomy"
+}
+/**
+ * Basic set of properties for every field.
+ */
+export interface BasicField {
+    /**
+     * Stable UI identity generated client-side (lodash `uniqueId`).
+     * Used by dnd-kit item IDs, Accordion item values, and DOM element IDs.
+     * Never sent to the backend — use `key` for the persisted field identifier.
+     */
+    id: string;
+    key: string;
+    type: FieldType;
+    name: string;
+    description?: string;
+    hidden: boolean;
+    dropdown: DropdownField['dropdown'];
+    taxonomy: TaxonomyField['taxonomy'];
+    isFieldNew: boolean;
+    isFieldReadOnly: boolean;
+}
+/**
+ * Describes possible data for any field. It branches based on the `type` property.
+ */
+export type FieldData = (BasicField & {
+    type: FieldType.Text | FieldType.Number | FieldType.Date;
+}) | (BasicField & DropdownField & {
+    type: FieldType.Dropdown;
+}) | (BasicField & TaxonomyField & {
+    type: FieldType.Taxonomy;
+});
+/**
+ * Represents a dropdown field with a non-empty array of options.
+ */
+export interface DropdownField {
+    dropdown: {
+        options: DropdownFieldOption[];
+        allowMultipleSelections: boolean;
+        isAllowMultipleSelectionsEnabled: boolean;
+    };
+}
+/**
+ * Represents options for dropdown field type.
+ */
+export interface DropdownFieldOption {
+    id: string;
+    key: string;
+    isNew: boolean;
+}
+/**
+ * Represents a taxonomy field.
+ */
+export interface TaxonomyField {
+    taxonomy: {
+        availableTaxonomies: TaxonomyOption[];
+        allowMultipleSelections: boolean;
+        selection: TaxonomySelection;
+        selectedLevels: number[];
+        taxonomyKey: string;
+        taxonomySearchValue: string;
+        namespace: string;
+    };
+}
+/**
+ * Represents a taxonomy option.
+ */
+export interface TaxonomyOption {
+    id: string;
+    label: string;
+    levels: TaxonomyLevel[];
+    selected: boolean;
+    taxonomyKey: string;
+    namespace: string;
+}
+/**
+ * Represents a taxonomy level.
+ */
+export interface TaxonomyLevel {
+    name: string;
+    level: number;
+}
+/**
+ * Represents the selection mode for a taxonomy field.
+ */
+export declare enum TaxonomySelection {
+    RequireSpecific = "requireSpecific",
+    AllowAny = "allowAny"
+}
+/**
+ * Represents the type of a field in a metadata template API response.
+ */
+export declare enum ApiMetadataTemplateFieldType {
+    Float = "float",
+    Taxonomy = "taxonomy",
+    MultiSelect = "multiSelect",
+    Date = "date",
+    String = "string",
+    Enum = "enum"
+}
+export type ApiDropdownFieldOption = {
+    key: string;
+};
+export type ApiMetadataTemplateFieldBase = {
+    key: string;
+    displayName: string;
+    description?: string;
+    isHidden: boolean;
+};
+export type ApiMetadataTemplateTextField = {
+    type: ApiMetadataTemplateFieldType.String;
+};
+export type ApiMetadataTemplateNumberField = {
+    type: ApiMetadataTemplateFieldType.Float;
+};
+export type ApiMetadataTemplateDateField = {
+    type: ApiMetadataTemplateFieldType.Date;
+};
+export type ApiMetadataTemplateTaxonomyField = {
+    type: ApiMetadataTemplateFieldType.Taxonomy;
+    taxonomyKey: string;
+    optionsRules: {
+        selectableLevels: number[];
+        multiSelect: boolean;
+    };
+    namespace: string;
+};
+export type ApiMetadataTemplateDropdownField = {
+    type: ApiMetadataTemplateFieldType.Enum | ApiMetadataTemplateFieldType.MultiSelect;
+    options: ApiDropdownFieldOption[];
+};
+export type ApiMetadataTemplateField = ApiMetadataTemplateFieldBase & (ApiMetadataTemplateTextField | ApiMetadataTemplateNumberField | ApiMetadataTemplateDateField | ApiMetadataTemplateTaxonomyField | ApiMetadataTemplateDropdownField);
+type MetadataTemplateBase = {
+    namespace: string;
+    templateKey: string;
+    displayName: string;
+};
+export type MetadataTemplateApiResponse = MetadataTemplateBase & {
+    fields: ApiMetadataTemplateField[];
+    isHidden: boolean;
+};
+export type MetadataTemplateEditorFormValues = MetadataTemplateBase & {
+    /**
+        this is a parameter after type conversion from api (MetadataTemplateField)
+        for easier handling in the field editor
+    */
+    fields: FieldData[];
+    /**
+     *  This visibility property parameter is different from the API response's `isHidden`
+        because there is a param name mismatch between get and put/post endpoints (`isHidden` vs `hidden`)
+     */
+    hidden: boolean;
+};
+/**
+ * A template field as expected by the create (POST) endpoint.
+ * Uses `hidden` (not `isHidden`) because of the param name mismatch between GET and POST endpoints.
+ */
+export type MetadataTemplateFieldCreateBody = Omit<ApiMetadataTemplateFieldBase, 'isHidden'> & {
+    hidden: boolean;
+} & (ApiMetadataTemplateTextField | ApiMetadataTemplateNumberField | ApiMetadataTemplateDateField | ApiMetadataTemplateTaxonomyField | ApiMetadataTemplateDropdownField);
+/**
+ * The full request body sent to the create (POST) endpoint.
+ * Fields are in the converted API-ready shape (with `hidden` instead of `isHidden`).
+ */
+export type MetadataTemplateCreateBody = MetadataTemplateBase & {
+    hidden: boolean;
+    fields: MetadataTemplateFieldCreateBody[];
+};
+export declare enum TemplateOperations {
+    EditTemplate = "editTemplate"
+}
+export declare enum FieldOperations {
+    AddField = "addField",
+    ReorderFields = "reorderFields",
+    EditField = "editField",
+    RemoveField = "removeField"
+}
+export declare enum EnumOperations {
+    AddEnumOption = "addEnumOption",
+    ReorderEnumOptions = "reorderEnumOptions",
+    EditEnumOption = "editEnumOption",
+    RemoveEnumOption = "removeEnumOption"
+}
+export declare enum MultiSelectOperations {
+    AddMultiSelectOption = "addMultiSelectOption",
+    ReorderMultiSelectOptions = "reorderMultiSelectOptions",
+    EditMultiSelectOption = "editMultiSelectOption",
+    RemoveMultiSelectOption = "removeMultiSelectOption"
+}
+export declare const AllOps: {
+    readonly AddMultiSelectOption: MultiSelectOperations.AddMultiSelectOption;
+    readonly ReorderMultiSelectOptions: MultiSelectOperations.ReorderMultiSelectOptions;
+    readonly EditMultiSelectOption: MultiSelectOperations.EditMultiSelectOption;
+    readonly RemoveMultiSelectOption: MultiSelectOperations.RemoveMultiSelectOption;
+    readonly AddEnumOption: EnumOperations.AddEnumOption;
+    readonly ReorderEnumOptions: EnumOperations.ReorderEnumOptions;
+    readonly EditEnumOption: EnumOperations.EditEnumOption;
+    readonly RemoveEnumOption: EnumOperations.RemoveEnumOption;
+    readonly AddField: FieldOperations.AddField;
+    readonly ReorderFields: FieldOperations.ReorderFields;
+    readonly EditField: FieldOperations.EditField;
+    readonly RemoveField: FieldOperations.RemoveField;
+    readonly EditTemplate: TemplateOperations.EditTemplate;
+};
+export type ValidOperations = (typeof AllOps)[keyof typeof AllOps];
+interface BaseOperation {
+    op: ValidOperations;
+}
+interface EditTemplateOperation extends BaseOperation {
+    op: TemplateOperations.EditTemplate;
+    data: {
+        displayName?: string;
+        hidden?: boolean;
+    };
+}
+interface AddFieldOperation extends BaseOperation {
+    op: FieldOperations.AddField;
+    fieldKey?: string;
+    data: ApiMetadataTemplateField;
+}
+interface ReorderFieldsOperation extends BaseOperation {
+    op: FieldOperations.ReorderFields;
+    fieldKeys: string[];
+}
+export interface EditFieldOperation extends BaseOperation {
+    op: FieldOperations.EditField;
+    fieldKey: string;
+    data: {
+        displayName?: string;
+        description?: string;
+        hidden?: boolean;
+    };
+}
+interface RemoveFieldOperation extends BaseOperation {
+    op: FieldOperations.RemoveField;
+    fieldKey: string;
+}
+interface AddEnumOptionOperation extends BaseOperation {
+    op: EnumOperations.AddEnumOption;
+    fieldKey: string;
+    data: {
+        key: string;
+    };
+}
+interface ReorderEnumOptionsOperation extends BaseOperation {
+    op: EnumOperations.ReorderEnumOptions;
+    fieldKey: string;
+    enumOptionKeys: string[];
+}
+interface EditEnumOptionOperation extends BaseOperation {
+    op: EnumOperations.EditEnumOption;
+    fieldKey: string;
+    enumOptionKey: string;
+    data: {
+        key: string;
+    };
+}
+interface RemoveEnumOptionOperation extends BaseOperation {
+    op: EnumOperations.RemoveEnumOption;
+    fieldKey: string;
+    enumOptionKey: string;
+}
+interface AddMultiSelectOptionOperation extends BaseOperation {
+    op: MultiSelectOperations.AddMultiSelectOption;
+    fieldKey: string;
+    data: {
+        key: string;
+    };
+}
+interface ReorderMultiSelectOptionsOperation extends BaseOperation {
+    op: MultiSelectOperations.ReorderMultiSelectOptions;
+    fieldKey: string;
+    multiSelectOptionKeys: string[];
+}
+interface EditMultiSelectOptionOperation extends BaseOperation {
+    op: MultiSelectOperations.EditMultiSelectOption;
+    fieldKey: string;
+    multiSelectOptionKey: string;
+    data: {
+        key: string;
+    };
+}
+interface RemoveMultiSelectOptionOperation extends BaseOperation {
+    op: MultiSelectOperations.RemoveMultiSelectOption;
+    fieldKey: string;
+    multiSelectOptionKey: string;
+}
+export type MetadataTemplatePatchItem = EditTemplateOperation | AddFieldOperation | ReorderFieldsOperation | EditFieldOperation | RemoveFieldOperation | AddEnumOptionOperation | ReorderEnumOptionsOperation | EditEnumOptionOperation | RemoveEnumOptionOperation | AddMultiSelectOptionOperation | ReorderMultiSelectOptionsOperation | EditMultiSelectOptionOperation | RemoveMultiSelectOptionOperation;
+export type TemplateUpdateRequestBody = MetadataTemplatePatchItem[];
+export {};

package/dist/types/lib/utils/constants.d.ts

@@ -0,0 +1,9 @@
+/** Max length for a metadata template field name (display name). */
+export declare const METADATA_TEMPLATE_FIELD_NAME_MAX_LENGTH = 4096;
+/** Max length for a metadata template field key. */
+export declare const METADATA_TEMPLATE_FIELD_KEY_MAX_LENGTH = 256;
+/** Max length for a metadata template key. */
+export declare const METADATA_TEMPLATE_KEY_MAX_LENGTH = 64;
+/** Max length for a metadata template name (display name). */
+export declare const METADATA_TEMPLATE_NAME_MAX_LENGTH = 4096;
+export declare const CONFLICT_HTTP_STATUS = 409;

package/dist/types/lib/utils/field-options/field-type-icon.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+import { FieldType } from '../../types';
+/**
+ * Returns an icon component based on the provided field type.
+ */
+export declare const FieldTypeIcon: (type: FieldType) => (props: React.SVGProps<SVGSVGElement>) => React.JSX.Element;

package/dist/types/lib/utils/field-options/index.d.ts

@@ -0,0 +1,4 @@
+export { FieldTypeIcon } from './field-type-icon';
+export { fieldTypeDescriptionMessages, fieldTypesTitleMessages } from './messages';
+export { useFieldOptions } from './useFieldOptions';
+export type { FieldOptionType, FieldOptionTypes } from './useFieldOptions';

package/dist/types/lib/utils/field-options/messages.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Field type labels for metadata template editor.
+ */
+export declare const fieldTypesTitleMessages: {
+    text: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    number: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    date: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    dropdown: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    taxonomy: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+};
+/**
+ * Detailed descriptions for each metadata field type.
+ */
+export declare const fieldTypeDescriptionMessages: {
+    text: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    number: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    date: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    dropdown: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    taxonomy: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+};