/**
 * Discriminates between creating, editing, or viewing a template in read-only mode.
 * Pass as the `mode` prop on `MetadataTemplateEditor` / `MetadataTemplateEditorModal`.
 */
export declare enum MetadataTemplateEditorMode {
    Create = "create",
    Edit = "edit",
    ReadOnly = "readOnly"
}
/**
 * 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)
 * - User - user field (select users and groups)
 * - Unsupported - deprecated/unknown API type (read-only; delete only; cannot be created)
 */
export declare enum FieldType {
    Text = "text",
    Number = "number",
    Date = "date",
    Dropdown = "dropdown",
    Taxonomy = "taxonomy",
    User = "user",
    Unsupported = "unsupported"
}
/** Field types that can be created via the type picker (excludes Unsupported). */
export type CreatableFieldType = Exclude<FieldType, FieldType.Unsupported>;
/** Field types that can be created via the type picker. */
export declare const CREATABLE_FIELD_TYPES: CreatableFieldType[];
/**
 * 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'];
    user: UserField['user'];
    isFieldNew: boolean;
    isFieldReadOnly: boolean;
    /**
     * Original API field type when `type` is `Unsupported` (e.g. `timeline`, `integer`).
     * Preserved so save never rewrites the type.
     */
    originalApiType?: string;
}
/**
 * Describes possible data for any field. It branches based on the `type` property.
 * Unsupported is a separate variant so type guards can narrow it away cleanly.
 */
export type FieldData = (BasicField & {
    type: FieldType.Text | FieldType.Number | FieldType.Date;
}) | (BasicField & {
    type: FieldType.Unsupported;
}) | (BasicField & DropdownField & {
    type: FieldType.Dropdown;
}) | (BasicField & TaxonomyField & {
    type: FieldType.Taxonomy;
}) | (BasicField & UserField & {
    type: FieldType.User;
});
export declare const isUnsupportedField: (field: Pick<BasicField, "type">) => field is Pick<BasicField, "type"> & {
    type: FieldType.Unsupported;
};
/**
 * 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 user field.
 */
export interface UserField {
    user: {
        allowMultipleSelections: boolean;
        notifyWhenUsersAreAdded: boolean;
    };
}
/**
 * Looks up a single taxonomy by namespace and key.
 *
 * Used to hydrate an existing field's display name and levels from
 * `GET /metadata_taxonomies/:namespace/:taxonomyKey` without loading the full catalogue.
 *
 * The shared feature stamps `id`, `namespace`, `taxonomyKey`, and `selected` from the
 * request. Hosts only need to return display metadata (`label` and `levels`).
 *
 * The Box API field is `key`, not `taxonomyKey`.
 *
 * @example
 * ```tsx
 * <MetadataTemplateEditor
 *   fetchTaxonomyByKey={async ({ namespace, taxonomyKey }) => {
 *     const taxonomy = await api.getTaxonomyByKey(namespace, taxonomyKey);
 *     return {
 *       label: taxonomy.displayName,
 *       levels: taxonomy.levels.map(level => ({ name: level.displayName, level: level.level })),
 *     };
 *   }}
 * />
 * ```
 */
export type FetchedTaxonomyDetails = Pick<TaxonomyOption, 'label' | 'levels'> & Partial<TaxonomyOption>;
export type FetchTaxonomyByKey = (params: {
    namespace: string;
    taxonomyKey: string;
}) => Promise<FetchedTaxonomyDetails>;
/**
 * 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",
    User = "user"
}
export type ApiDropdownFieldOption = {
    key: string;
};
export type ApiMetadataTemplateFieldBase = {
    key: string;
    displayName: string;
    description?: string;
    hidden: boolean;
};
export type TaxonomyOptionRules = {
    selectableLevels: number[];
    multiSelect: boolean;
};
export type UserFieldOptionRules = {
    allowMultipleSelections: boolean;
    notifyWhenUsersAreAdded: boolean;
};
type OptionRules = TaxonomyOptionRules | UserFieldOptionRules;
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: TaxonomyOptionRules;
    namespace: string;
};
export type ApiMetadataTemplateDropdownField = {
    type: ApiMetadataTemplateFieldType.Enum | ApiMetadataTemplateFieldType.MultiSelect;
    options: ApiDropdownFieldOption[];
};
export type ProposedUserFieldPayload = {
    type: ApiMetadataTemplateFieldType.User;
    optionsRules: UserFieldOptionRules;
};
export type ApiMetadataTemplateKnownField = ApiMetadataTemplateFieldBase & (ApiMetadataTemplateTextField | ApiMetadataTemplateNumberField | ApiMetadataTemplateDateField | ApiMetadataTemplateTaxonomyField | ApiMetadataTemplateDropdownField | ProposedUserFieldPayload);
/**
 * Field shape from the API when loading a template for edit.
 * `type` is a string so deprecated/unknown types (e.g. timeline, integer) are accepted.
 */
export type ApiMetadataTemplateFieldFromApi = ApiMetadataTemplateFieldBase & {
    type: string;
    options?: ApiDropdownFieldOption[];
    optionsRules?: OptionRules;
    taxonomyKey?: string;
    namespace?: string;
};
/** Known or unknown API field — used when reading templates that may contain deprecated types. */
export type ApiMetadataTemplateField = ApiMetadataTemplateKnownField | ApiMetadataTemplateFieldFromApi;
type MetadataTemplateBase = {
    namespace: string;
    templateKey: string;
    displayName: string;
};
/**
 * Metadata template as returned by GET endpoints (e.g. get template by ID).
 * Matches the Box API shape — visibility is `hidden` on both template and fields.
 */
export type MetadataTemplateApiResponse = MetadataTemplateBase & {
    fields: ApiMetadataTemplateField[];
    hidden: boolean;
};
/**
 * Form values for the metadata template editor/creator.
 * Field shapes are converted from the API into `FieldData` for the configurator UI.
 */
export type MetadataTemplateEditorFormValues = MetadataTemplateBase & {
    fields: FieldData[];
    hidden: boolean;
};
/**
 * A template field as expected by create (POST) and AddField patch payloads.
 * Same visibility property (`hidden`) as the GET response field shape.
 * Unsupported/deprecated API types cannot be created.
 */
export type MetadataTemplateFieldCreateBody = ApiMetadataTemplateKnownField;
/**
 * The full request body sent to the create (POST) endpoint.
 */
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: MetadataTemplateFieldCreateBody;
}
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;
        optionsRules?: UserFieldOptionRules;
    };
}
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 {};