import type { BlokkliFragmentName } from '#blokkli-build/definitions';
import type { FieldListItem } from '#blokkli/types';
import type { ValidFieldListTypes, FieldListItemTyped } from '#blokkli-build/generated-types';
import type { FieldDropAlignment } from '#blokkli/types/field';
import type { VueClassProp } from '#blokkli/types/vue';
type __VLS_Props = {
    /**
     * The name of the field.
     */
    name: string;
    /**
     * The field list items. Can be an array or a single item, also allows nullable values in an array.
     */
    list?: Array<FieldListItem | null | undefined> | FieldListItem | null;
    /**
     * The tag to use for rendering the root element.
     */
    tag?: string;
    /**
     * The field list types. The available types can be defined in the "fieldListTypes" module option.
     */
    fieldListType?: ValidFieldListTypes;
    /**
     * If true, the field list items are only rendered in edit mode.
     * In normal mode, you are responsible yourself to render the items.
     */
    editOnly?: boolean;
    /**
     * The classes to render for the list. Same as passing classes via the :class prop.
     */
    listClass?: VueClassProp;
    /**
     * Classes only applied during editing.
     */
    editClass?: VueClassProp;
    /**
     * Classes to apply if the field is not empty.
     */
    nonEmptyClass?: string;
    /**
     * Define which fragments are allowed in this field.
     *
     * Note that this is only used during editing. It defines which fragments
     * can be added here. If you change this prop but there are existing
     * fragments already in the field list, they will continue to be rendered.
     *
     * Note that in addition, also the "blokkli_fragment" block must be allowed
     * as a bundle in this field.
     */
    allowedFragments?: BlokkliFragmentName[] | BlokkliFragmentName;
    /**
     * Force an alignment during drag and drop interactions.
     */
    dropAlignment?: FieldDropAlignment;
    /**
     * The z-index of this field, used to resolve overlapping blocks at the same
     * nesting level. Higher values take priority. Default is 0.
     */
    zIndex?: number | string;
    /**
     * Renders proxy blocks during editing.
     *
     * Doing this will *not* render the actual block components.
     *
     * During editing, a separate element is rendered with "position: absolute"
     * that contains "proxy blocks" for drag and drop interactions. This means
     * that you need to have a wrapper somewhere with "position: relative".
     */
    proxyMode?: boolean;
    /**
     * Determine whether an item should be rendered.
     */
    shouldRenderItem?: (item: FieldListItem | FieldListItemTyped) => boolean;
};
type __VLS_Slots = {
    default(props: {
        items: FieldListItemTyped[];
    }): any;
    after(props: {
        items: FieldListItemTyped[];
    }): any;
};
declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
    tag: string;
    fieldListType: ValidFieldListTypes;
    allowedFragments: BlokkliFragmentName[] | BlokkliFragmentName;
    dropAlignment: FieldDropAlignment;
    zIndex: number | string;
    list: Array<FieldListItem | null | undefined> | FieldListItem | null;
    shouldRenderItem: (item: FieldListItem | FieldListItemTyped) => boolean;
    listClass: VueClassProp;
    editClass: VueClassProp;
    nonEmptyClass: string;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
declare const _default: typeof __VLS_export;
export default _default;
type __VLS_WithSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};