Class CronAnt

Index

Constructors

Methods

$watch activated? beforeCreate? beforeDestroy? beforeMount? beforeUnmount? beforeUpdate? created? deactivated? destroyed? mounted? serverPrefetch? unmounted? updated?

Constructors

constructor

new CronAnt(...args: any[]): CronAnt
Parameters
- ...args: any[]
Returns CronAnt
- Defined in node_modules/@vue/runtime-core/dist/runtime-core.d.ts:487

Properties

$

$: ComponentInternalInstance

$attrs

$attrs: Attrs

$data

$data: {}

$el

$el: any

$emit

$emit: (
event: "update:model-value" | "update:period" | "error",
...args: any[],
) => void

$forceUpdate

$forceUpdate: () => void

$host

$host: Element | null

$nextTick

$nextTick: {
(): Promise<void>;
<T, R>(this: T, fn: (this: T) => R | Promise<R>): Promise<R>;
}

$options

$options: ComponentOptionsBase<
    Readonly<
        ExtractPropTypes<
            {
                buttonProps: {
                    type: PropType<
                        Partial<
                            ExtractPropTypes<
                                {
                                    block: ...;
                                    danger: ...;
                                    disabled: ...;
                                    ghost: ...;
                                    href: ...;
                                    htmlType: ...;
                                    icon: ...;
                                    loading: ...;
                                    onClick: ...;
                                    onMousedown: ...;
                                    prefixCls: ...;
                                    shape: ...;
                                    size: ...;
                                    target: ...;
                                    title: ...;
                                    type: ...;
                                },
                            >,
                        >,
                    >;
                    default(): {};
                };
                clearable: { default: boolean; type: BooleanConstructor };
                cols: {
                    default: () => {
                        day: number;
                        hour: number;
                        minute: number;
                        second: number;
                    };
                    type: PropType<Record<string, number>>;
                };
                customLocale: { type: PropType<Localization> };
                disabled: { default: boolean; type: BooleanConstructor };
                dropdownProps: {
                    default: () => void;
                    type: PropType<
                        Partial<
                            ExtractPropTypes<
                                {
                                    align: ...;
                                    arrow: ...;
                                    destroyPopupOnHide: ...;
                                    disabled: ...;
                                    forceRender: ...;
                                    getPopupContainer: ...;
                                    minOverlayWidthMatchTrigger: ...;
                                    mouseEnterDelay: ...;
                                    mouseLeaveDelay: ...;
                                    "onUpdate:visible": ...;
                                    onVisibleChange: ...;
                                    openClassName: ...;
                                    overlay: ...;
                                    overlayClassName: ...;
                                    overlayStyle: ...;
                                    placement: ...;
                                    prefixCls: ...;
                                    transitionName: ...;
                                    trigger: ...;
                                    visible: ...;
                                },
                            >,
                        >,
                    >;
                };
                fields: { type: PropType<Field[]> };
                format: { type: PropType<CronFormat> };
                locale: { type: StringConstructor };
                modelValue: { type: StringConstructor };
                period: { type: StringConstructor };
                periods: { type: PropType<Period[]> };
            },
        >,
    > & Readonly<
        {
            onError?: (...args: any[]) => any;
            "onUpdate:model-value"?: (...args: any[]) => any;
            "onUpdate:period"?: (...args: any[]) => any;
        },
    >,
    {
        cron: Ref<string, string>;
        error: Ref<string, string>;
        period: {
            items: { id: string; text: any; value: string[] }[];
            prefix: Ref<string, string>;
            select: (periodId: string) => void;
            selected: Ref<
                | { id: string; text?: string; value: string[] }
                | { id: string; text: any; value: string[] },

                    | Period
                    | { id: string; text: any; value: string[] }
                    | { id: string; text?: string; value: string[] }
                    | { id: string; text: any; value: string[] },
            >;
            suffix: Ref<string, string>;
        };
        segments: {
            cron: Ref<string, string>;
            error: Ref<string, string>;
            id: string;
            items: FieldItem[];
            prefix: Ref<string, string>;
            select: (evt: number[]) => void;
            selected: Ref<number[], number[]>;
            suffix: Ref<string, string>;
            text: Ref<string, string>;
        }[];
        selected: ComputedRef<
            {
                cron: Ref<string, string>;
                error: Ref<string, string>;
                id: string;
                items: FieldItem[];
                prefix: Ref<string, string>;
                select: (evt: number[]) => void;
                selected: Ref<number[], number[]>;
                suffix: Ref<string, string>;
                text: Ref<string, string>;
            }[],
        >;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    ("update:model-value" | "update:period" | "error")[],
    string,
    {
        buttonProps: Partial<
            ExtractPropTypes<
                {
                    block: { default: any; type: BooleanConstructor };
                    danger: { default: any; type: BooleanConstructor };
                    disabled: { default: any; type: BooleanConstructor };
                    ghost: { default: any; type: BooleanConstructor };
                    href: StringConstructor;
                    htmlType: { default: string; type: PropType<ButtonHTMLType> };
                    icon: VueTypeValidableDef<any>;
                    loading: {
                        default: () => boolean | { delay?: number };
                        type: PropType<boolean | { delay?: number }>;
                    };
                    onClick: { type: PropType<(event: MouseEvent) => void> };
                    onMousedown: { type: PropType<(event: MouseEvent) => void> };
                    prefixCls: StringConstructor;
                    shape: { type: PropType<ButtonShape> };
                    size: { type: PropType<ButtonSize> };
                    target: StringConstructor;
                    title: StringConstructor;
                    type: PropType<ButtonType>;
                },
            >,
        >;
        clearable: boolean;
        cols: Record<string, number>;
        disabled: boolean;
        dropdownProps: Partial<
            ExtractPropTypes<
                {
                    align: { type: PropType<Align> };
                    arrow: { default: any; type: PropType<boolean | DropdownArrowOptions> };
                    destroyPopupOnHide: { default: any; type: BooleanConstructor };
                    disabled: { default: any; type: BooleanConstructor };
                    forceRender: { default: any; type: BooleanConstructor };
                    getPopupContainer: PropType<(triggerNode: HTMLElement) => HTMLElement>;
                    minOverlayWidthMatchTrigger: { default: any; type: BooleanConstructor };
                    mouseEnterDelay: NumberConstructor;
                    mouseLeaveDelay: NumberConstructor;
                    "onUpdate:visible": { type: PropType<(val: boolean) => void> };
                    onVisibleChange: { type: PropType<(val: boolean) => void> };
                    openClassName: StringConstructor;
                    overlay: VueTypeValidableDef<any>;
                    overlayClassName: StringConstructor;
                    overlayStyle: { default: CSSProperties; type: PropType<CSSProperties> };
                    placement: PropType<
                        | "bottom"
                        | "top"
                        | "bottomLeft"
                        | "bottomRight"
                        | "topLeft"
                        | "topRight"
                        | "topCenter"
                        | "bottomCenter",
                    >;
                    prefixCls: StringConstructor;
                    transitionName: StringConstructor;
                    trigger: { type: PropType<Trigger | Trigger[]> };
                    visible: { default: any; type: BooleanConstructor };
                },
            >,
        >;
    },
    {},
    string,
    {},
    {
        CustomSelect: DefineComponent<
            ExtractPropTypes<
                {
                    buttonProps: {
                        default: () => void;
                        type: PropType<Partial<ExtractPropTypes<(...)>>>;
                    };
                    clearable: { default: boolean; type: BooleanConstructor };
                    cols: { default: number; type: NumberConstructor };
                    disabled: { default: boolean; type: BooleanConstructor };
                    dropdownProps: {
                        default: () => void;
                        type: PropType<Partial<ExtractPropTypes<(...)>>>;
                    };
                    hideOnClick: { default: boolean; type: BooleanConstructor };
                    items: { default: () => never[]; type: PropType<any[]> };
                    itemText: {
                        default: string;
                        type: PropType<string | ((item: ...) => ...)>;
                    };
                    itemValue: {
                        default: string;
                        type: PropType<string | ((item: ...) => ...)>;
                    };
                    modelValue: { type: PropType<string | number | (...)[]> };
                    multiple: { default: boolean; type: BooleanConstructor };
                    selection: { type: StringConstructor };
                },
            >,
            {
                add: (item: any) => void;
                clear: () => void;
                equals: (items: any[]) => boolean;
                has: (item: any) => boolean;
                isEmpty: ComputedRef<boolean>;
                itemRows: any[][];
                remove: (item: any) => void;
                select: (item: any) => void;
                selected: Ref<
                    | string
                    | number
                    | (string | number)[]
                    | (string | number | (...)[] | undefined)[]
                    | undefined,

                        | string
                        | number
                        | (string | number)[]
                        | (string | number | (...)[] | undefined)[]
                        | undefined,
                >;
                selectedKeys: ComputedRef<(string | number)[]>;
                selectedStr: Ref<string, string>;
                setItems: (items: any[]) => void;
                setValues: (
                    values:
                        | string
                        | number
                        | (string | number)[]
                        | (string | number | (...)[] | undefined)[]
                        | undefined,
                ) => void;
                toggle: (item: any) => void;
                updated: Ref<number, number>;
                updateVisibility: () => void;
                values: Set<any>;
                visible: Ref<boolean, boolean>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            "update:model-value"[],
            "update:model-value",
            PublicProps,
            Readonly<
                ExtractPropTypes<
                    {
                        buttonProps: { default: () => ...; type: PropType<(...)> };
                        clearable: { default: boolean; type: BooleanConstructor };
                        cols: { default: number; type: NumberConstructor };
                        disabled: { default: boolean; type: BooleanConstructor };
                        dropdownProps: { default: () => ...; type: PropType<(...)> };
                        hideOnClick: { default: boolean; type: BooleanConstructor };
                        items: { default: () => ...; type: PropType<(...)> };
                        itemText: { default: string; type: PropType<(...)> };
                        itemValue: { default: string; type: PropType<(...)> };
                        modelValue: { type: PropType<(...)> };
                        multiple: { default: boolean; type: BooleanConstructor };
                        selection: { type: StringConstructor };
                    },
                >,
            > & Readonly<{ "onUpdate:model-value"?: (...args: (...)[]) => any }>,
            {
                buttonProps: Partial<
                    ExtractPropTypes<
                        {
                            block: { default: any; type: BooleanConstructor };
                            danger: { default: any; type: BooleanConstructor };
                            disabled: { default: any; type: BooleanConstructor };
                            ghost: { default: any; type: BooleanConstructor };
                            href: StringConstructor;
                            htmlType: { default: string; type: PropType<(...)> };
                            icon: VueTypeValidableDef<any>;
                            loading: { default: () => ...; type: PropType<(...)> };
                            onClick: { type: PropType<(...)> };
                            onMousedown: { type: PropType<(...)> };
                            prefixCls: StringConstructor;
                            shape: { type: PropType<(...)> };
                            size: { type: PropType<(...)> };
                            target: StringConstructor;
                            title: StringConstructor;
                            type: PropType<ButtonType>;
                        },
                    >,
                >;
                clearable: boolean;
                cols: number;
                disabled: boolean;
                dropdownProps: Partial<
                    ExtractPropTypes<
                        {
                            align: { type: PropType<(...)> };
                            arrow: { default: any; type: PropType<(...)> };
                            destroyPopupOnHide: { default: any; type: BooleanConstructor };
                            disabled: { default: any; type: BooleanConstructor };
                            forceRender: { default: any; type: BooleanConstructor };
                            getPopupContainer: PropType<(triggerNode: ...) => ...>;
                            minOverlayWidthMatchTrigger: {
                                default: any;
                                type: BooleanConstructor;
                            };
                            mouseEnterDelay: NumberConstructor;
                            mouseLeaveDelay: NumberConstructor;
                            "onUpdate:visible": { type: PropType<(...)> };
                            onVisibleChange: { type: PropType<(...)> };
                            openClassName: StringConstructor;
                            overlay: VueTypeValidableDef<any>;
                            overlayClassName: StringConstructor;
                            overlayStyle: { default: CSSProperties; type: PropType<(...)> };
                            placement: PropType<
                                (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...),
                            >;
                            prefixCls: StringConstructor;
                            transitionName: StringConstructor;
                            trigger: { type: PropType<(...)> };
                            visible: { default: any; type: BooleanConstructor };
                        },
                    >,
                >;
                hideOnClick: boolean;
                items: any[];
                itemText: string
                | ((item: any) => string);
                itemValue: string | ((item: any) => string | number);
                multiple: boolean;
            },
            {},
            { CloseCircleFilled: CloseCircleFilledIconType },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any,
        >;
    } & GlobalComponents,
    GlobalDirectives,
    string,
    ComponentProvideOptions,
> & MergedComponentOptionsOverride

$parent

$parent:
    | ComponentPublicInstance<
        {},
        {},
        {},
        {},
        {},
        {},
        {},
        {},
        false,
        ComponentOptionsBase<
            any,
            any,
            any,
            any,
            any,
            any,
            any,
            any,
            any,
            {},
            {},
            string,
            {},
            {},
            {},
            string,
            ComponentProvideOptions,
        >,
        {},
        {},
        "",
        {},
        any,
    >
    | null

$props

$props: Partial<
    {
        buttonProps: Partial<
            ExtractPropTypes<
                {
                    block: { default: any; type: BooleanConstructor };
                    danger: { default: any; type: BooleanConstructor };
                    disabled: { default: any; type: BooleanConstructor };
                    ghost: { default: any; type: BooleanConstructor };
                    href: StringConstructor;
                    htmlType: { default: string; type: PropType<ButtonHTMLType> };
                    icon: VueTypeValidableDef<any>;
                    loading: {
                        default: () => boolean | { delay?: number };
                        type: PropType<boolean | { delay?: number }>;
                    };
                    onClick: { type: PropType<(event: MouseEvent) => void> };
                    onMousedown: { type: PropType<(event: MouseEvent) => void> };
                    prefixCls: StringConstructor;
                    shape: { type: PropType<ButtonShape> };
                    size: { type: PropType<ButtonSize> };
                    target: StringConstructor;
                    title: StringConstructor;
                    type: PropType<ButtonType>;
                },
            >,
        >;
        clearable: boolean;
        cols: Record<string, number>;
        disabled: boolean;
        dropdownProps: Partial<
            ExtractPropTypes<
                {
                    align: { type: PropType<Align> };
                    arrow: { default: any; type: PropType<boolean | DropdownArrowOptions> };
                    destroyPopupOnHide: { default: any; type: BooleanConstructor };
                    disabled: { default: any; type: BooleanConstructor };
                    forceRender: { default: any; type: BooleanConstructor };
                    getPopupContainer: PropType<(triggerNode: HTMLElement) => HTMLElement>;
                    minOverlayWidthMatchTrigger: { default: any; type: BooleanConstructor };
                    mouseEnterDelay: NumberConstructor;
                    mouseLeaveDelay: NumberConstructor;
                    "onUpdate:visible": { type: PropType<(val: boolean) => void> };
                    onVisibleChange: { type: PropType<(val: boolean) => void> };
                    openClassName: StringConstructor;
                    overlay: VueTypeValidableDef<any>;
                    overlayClassName: StringConstructor;
                    overlayStyle: { default: CSSProperties; type: PropType<CSSProperties> };
                    placement: PropType<
                        | "bottom"
                        | "top"
                        | "bottomLeft"
                        | "bottomRight"
                        | "topLeft"
                        | "topRight"
                        | "topCenter"
                        | "bottomCenter",
                    >;
                    prefixCls: StringConstructor;
                    transitionName: StringConstructor;
                    trigger: { type: PropType<Trigger | Trigger[]> };
                    visible: { default: any; type: BooleanConstructor };
                },
            >,
        >;
    },
> & Omit<
    {
        buttonProps: Partial<
            ExtractPropTypes<
                {
                    block: { default: any; type: BooleanConstructor };
                    danger: { default: any; type: BooleanConstructor };
                    disabled: { default: any; type: BooleanConstructor };
                    ghost: { default: any; type: BooleanConstructor };
                    href: StringConstructor;
                    htmlType: { default: string; type: PropType<ButtonHTMLType> };
                    icon: VueTypeValidableDef<any>;
                    loading: {
                        default: () => boolean | { delay?: ... };
                        type: PropType<boolean | { delay?: ... }>;
                    };
                    onClick: { type: PropType<(event: MouseEvent) => void> };
                    onMousedown: { type: PropType<(event: MouseEvent) => void> };
                    prefixCls: StringConstructor;
                    shape: { type: PropType<ButtonShape> };
                    size: { type: PropType<SizeType> };
                    target: StringConstructor;
                    title: StringConstructor;
                    type: PropType<ButtonType>;
                },
            >,
        >;
        clearable: boolean;
        cols: Record<string, number>;
        customLocale?: Localization;
        disabled: boolean;
        dropdownProps: Partial<
            ExtractPropTypes<
                {
                    align: { type: PropType<Align> };
                    arrow: { default: any; type: PropType<boolean | DropdownArrowOptions> };
                    destroyPopupOnHide: { default: any; type: BooleanConstructor };
                    disabled: { default: any; type: BooleanConstructor };
                    forceRender: { default: any; type: BooleanConstructor };
                    getPopupContainer: PropType<(triggerNode: HTMLElement) => HTMLElement>;
                    minOverlayWidthMatchTrigger: { default: any; type: BooleanConstructor };
                    mouseEnterDelay: NumberConstructor;
                    mouseLeaveDelay: NumberConstructor;
                    "onUpdate:visible": { type: PropType<(val: boolean) => void> };
                    onVisibleChange: { type: PropType<(val: boolean) => void> };
                    openClassName: StringConstructor;
                    overlay: VueTypeValidableDef<any>;
                    overlayClassName: StringConstructor;
                    overlayStyle: { default: CSSProperties; type: PropType<CSSProperties> };
                    placement: PropType<
                        | "bottom"
                        | "top"
                        | "bottomLeft"
                        | "bottomRight"
                        | "topLeft"
                        | "topRight"
                        | "topCenter"
                        | "bottomCenter",
                    >;
                    prefixCls: StringConstructor;
                    transitionName: StringConstructor;
                    trigger: { type: PropType<Trigger | (...)[]> };
                    visible: { default: any; type: BooleanConstructor };
                },
            >,
        >;
        fields?: Field[];
        format?: CronFormat;
        locale?: string;
        modelValue?: string;
        onError?: (...args: any[]) => any;
        "onUpdate:model-value"?: (...args: any[]) => any;
        "onUpdate:period"?: (...args: any[]) => any;
        period?: string;
        periods?: Period[];
    } & VNodeProps & AllowedComponentProps & ComponentCustomProps,
    "cols"
    | "disabled"
    | "clearable"
    | "buttonProps"
    | "dropdownProps",
>

$refs

$refs: Data

$root

$root:
    | ComponentPublicInstance<
        {},
        {},
        {},
        {},
        {},
        {},
        {},
        {},
        false,
        ComponentOptionsBase<
            any,
            any,
            any,
            any,
            any,
            any,
            any,
            any,
            any,
            {},
            {},
            string,
            {},
            {},
            {},
            string,
            ComponentProvideOptions,
        >,
        {},
        {},
        "",
        {},
        any,
    >
    | null

$slots

$slots: UnwrapSlotsType<S>

`Readonly`buttonProps

buttonProps: Partial<
    ExtractPropTypes<
        {
            block: { default: any; type: BooleanConstructor };
            danger: { default: any; type: BooleanConstructor };
            disabled: { default: any; type: BooleanConstructor };
            ghost: { default: any; type: BooleanConstructor };
            href: StringConstructor;
            htmlType: { default: string; type: PropType<ButtonHTMLType> };
            icon: VueTypeValidableDef<any>;
            loading: {
                default: () => boolean | { delay?: number };
                type: PropType<boolean | { delay?: number }>;
            };
            onClick: { type: PropType<(event: MouseEvent) => void> };
            onMousedown: { type: PropType<(event: MouseEvent) => void> };
            prefixCls: StringConstructor;
            shape: { type: PropType<ButtonShape> };
            size: { type: PropType<ButtonSize> };
            target: StringConstructor;
            title: StringConstructor;
            type: PropType<ButtonType>;
        },
    >,
>

`Readonly`clearable

clearable: boolean

`Readonly`cols

cols: Record<string, number>

cron

cron: string

`Optional` `Readonly`customLocale

customLocale?: Localization

`Readonly`disabled

disabled: boolean

`Readonly`dropdownProps

dropdownProps: Partial<
    ExtractPropTypes<
        {
            align: { type: PropType<Align> };
            arrow: { default: any; type: PropType<boolean | DropdownArrowOptions> };
            destroyPopupOnHide: { default: any; type: BooleanConstructor };
            disabled: { default: any; type: BooleanConstructor };
            forceRender: { default: any; type: BooleanConstructor };
            getPopupContainer: PropType<(triggerNode: HTMLElement) => HTMLElement>;
            minOverlayWidthMatchTrigger: { default: any; type: BooleanConstructor };
            mouseEnterDelay: NumberConstructor;
            mouseLeaveDelay: NumberConstructor;
            "onUpdate:visible": { type: PropType<(val: boolean) => void> };
            onVisibleChange: { type: PropType<(val: boolean) => void> };
            openClassName: StringConstructor;
            overlay: VueTypeValidableDef<any>;
            overlayClassName: StringConstructor;
            overlayStyle: { default: CSSProperties; type: PropType<CSSProperties> };
            placement: PropType<
                | "bottom"
                | "top"
                | "bottomLeft"
                | "bottomRight"
                | "topLeft"
                | "topRight"
                | "topCenter"
                | "bottomCenter",
            >;
            prefixCls: StringConstructor;
            transitionName: StringConstructor;
            trigger: { type: PropType<Trigger | Trigger[]> };
            visible: { default: any; type: BooleanConstructor };
        },
    >,
>

error

error: string

`Optional` `Readonly`fields

fields?: Field[]

`Optional` `Readonly`format

format?: CronFormat

`Optional` `Readonly`locale

locale?: string

`Optional` `Readonly`modelValue

modelValue?: string

`Optional` `Readonly`onError

onError?: (...args: any[]) => any

`Optional` `Readonly`onUpdate:model-value

"onUpdate:model-value"?: (...args: any[]) => any

`Optional` `Readonly`onUpdate:period

"onUpdate:period"?: (...args: any[]) => any

period

period: {
    items: { id: string; text: any; value: string[] }[];
    prefix: Ref<string, string>;
    select: (periodId: string) => void;
    selected: Ref<
        | { id: string; text?: string; value: string[] }
        | { id: string; text: any; value: string[] },

            | Period
            | { id: string; text: any; value: string[] }
            | { id: string; text?: string; value: string[] }
            | { id: string; text: any; value: string[] },
    >;
    suffix: Ref<string, string>;
}

`Optional` `Readonly`periods

periods?: Period[]

segments

segments: {
    cron: Ref<string, string>;
    error: Ref<string, string>;
    id: string;
    items: FieldItem[];
    prefix: Ref<string, string>;
    select: (evt: number[]) => void;
    selected: Ref<number[], number[]>;
    suffix: Ref<string, string>;
    text: Ref<string, string>;
}[]

selected

selected: {
    cron: Ref<string, string>;
    error: Ref<string, string>;
    id: string;
    items: FieldItem[];
    prefix: Ref<string, string>;
    select: (evt: number[]) => void;
    selected: Ref<number[], number[]>;
    suffix: Ref<string, string>;
    text: Ref<string, string>;
}[]

`Static` `Optional`__defaults

__defaults?: {
    buttonProps: Partial<
        ExtractPropTypes<
            {
                block: { default: any; type: BooleanConstructor };
                danger: { default: any; type: BooleanConstructor };
                disabled: { default: any; type: BooleanConstructor };
                ghost: { default: any; type: BooleanConstructor };
                href: StringConstructor;
                htmlType: { default: string; type: PropType<ButtonHTMLType> };
                icon: VueTypeValidableDef<any>;
                loading: {
                    default: () => boolean | { delay?: number };
                    type: PropType<boolean | { delay?: number }>;
                };
                onClick: { type: PropType<(event: MouseEvent) => void> };
                onMousedown: { type: PropType<(event: MouseEvent) => void> };
                prefixCls: StringConstructor;
                shape: { type: PropType<ButtonShape> };
                size: { type: PropType<ButtonSize> };
                target: StringConstructor;
                title: StringConstructor;
                type: PropType<ButtonType>;
            },
        >,
    >;
    clearable: boolean;
    cols: Record<string, number>;
    disabled: boolean;
    dropdownProps: Partial<
        ExtractPropTypes<
            {
                align: { type: PropType<Align> };
                arrow: { default: any; type: PropType<boolean | DropdownArrowOptions> };
                destroyPopupOnHide: { default: any; type: BooleanConstructor };
                disabled: { default: any; type: BooleanConstructor };
                forceRender: { default: any; type: BooleanConstructor };
                getPopupContainer: PropType<(triggerNode: HTMLElement) => HTMLElement>;
                minOverlayWidthMatchTrigger: { default: any; type: BooleanConstructor };
                mouseEnterDelay: NumberConstructor;
                mouseLeaveDelay: NumberConstructor;
                "onUpdate:visible": { type: PropType<(val: boolean) => void> };
                onVisibleChange: { type: PropType<(val: boolean) => void> };
                openClassName: StringConstructor;
                overlay: VueTypeValidableDef<any>;
                overlayClassName: StringConstructor;
                overlayStyle: { default: CSSProperties; type: PropType<CSSProperties> };
                placement: PropType<
                    | "bottom"
                    | "top"
                    | "bottomLeft"
                    | "bottomRight"
                    | "topLeft"
                    | "topRight"
                    | "topCenter"
                    | "bottomCenter",
                >;
                prefixCls: StringConstructor;
                transitionName: StringConstructor;
                trigger: { type: PropType<Trigger | Trigger[]> };
                visible: { default: any; type: BooleanConstructor };
            },
        >,
    >;
}

`Static` `Optional`__differentiator

__differentiator?: undefined

#3468

type-only, used to assist Mixin's type inference, TypeScript will try to simplify the inferred Mixin type, with the __differentiator, TypeScript won't be able to combine different mixins, because the __differentiator will be different

`Static` `Optional`__file

__file?: string

This one should be exposed so that devtools can make use of it

`Static` `Optional`__isBuiltIn

__isBuiltIn?: boolean

Compat build only, for bailing out of certain compatibility behavior

`Static` `Optional`__isFragment

__isFragment?: undefined

`Static` `Optional`__isSuspense

__isSuspense?: undefined

`Static` `Optional`__isTeleport

__isTeleport?: undefined

`Static` `Optional`__name

__name?: string

name inferred from filename

`Static` `Optional`call

call?: (this: unknown, ...args: unknown[]) => never

`Static` `Optional`class

class?: unknown

`Static` `Optional`compatConfig

compatConfig?: CompatConfig

`Static` `Optional`compilerOptions

compilerOptions?: RuntimeCompilerOptions

`Static` `Optional`components

components?: {
    CustomSelect: DefineComponent<
        ExtractPropTypes<
            {
                buttonProps: {
                    default: () => void;
                    type: PropType<
                        Partial<
                            ExtractPropTypes<
                                {
                                    block: ...;
                                    danger: ...;
                                    disabled: ...;
                                    ghost: ...;
                                    href: ...;
                                    htmlType: ...;
                                    icon: ...;
                                    loading: ...;
                                    onClick: ...;
                                    onMousedown: ...;
                                    prefixCls: ...;
                                    shape: ...;
                                    size: ...;
                                    target: ...;
                                    title: ...;
                                    type: ...;
                                },
                            >,
                        >,
                    >;
                };
                clearable: { default: boolean; type: BooleanConstructor };
                cols: { default: number; type: NumberConstructor };
                disabled: { default: boolean; type: BooleanConstructor };
                dropdownProps: {
                    default: () => void;
                    type: PropType<
                        Partial<
                            ExtractPropTypes<
                                {
                                    align: ...;
                                    arrow: ...;
                                    destroyPopupOnHide: ...;
                                    disabled: ...;
                                    forceRender: ...;
                                    getPopupContainer: ...;
                                    minOverlayWidthMatchTrigger: ...;
                                    mouseEnterDelay: ...;
                                    mouseLeaveDelay: ...;
                                    "onUpdate:visible": ...;
                                    onVisibleChange: ...;
                                    openClassName: ...;
                                    overlay: ...;
                                    overlayClassName: ...;
                                    overlayStyle: ...;
                                    placement: ...;
                                    prefixCls: ...;
                                    transitionName: ...;
                                    trigger: ...;
                                    visible: ...;
                                },
                            >,
                        >,
                    >;
                };
                hideOnClick: { default: boolean; type: BooleanConstructor };
                items: { default: () => never[]; type: PropType<any[]> };
                itemText: {
                    default: string;
                    type: PropType<string | ((item: any) => string)>;
                };
                itemValue: {
                    default: string;
                    type: PropType<string | ((item: any) => (...) | (...))>;
                };
                modelValue: { type: PropType<string | number | ((...) | (...))[]> };
                multiple: { default: boolean; type: BooleanConstructor };
                selection: { type: StringConstructor };
            },
        >,
        {
            add: (item: any) => void;
            clear: () => void;
            equals: (items: any[]) => boolean;
            has: (item: any) => boolean;
            isEmpty: ComputedRef<boolean>;
            itemRows: any[][];
            remove: (item: any) => void;
            select: (item: any) => void;
            selected: Ref<
                | string
                | number
                | (string | number)[]
                | (string | number | ((...) | (...))[] | undefined)[]
                | undefined,

                    | string
                    | number
                    | (string | number)[]
                    | (string | number | ((...) | (...))[] | undefined)[]
                    | undefined,
            >;
            selectedKeys: ComputedRef<(string | number)[]>;
            selectedStr: Ref<string, string>;
            setItems: (items: any[]) => void;
            setValues: (
                values:
                    | string
                    | number
                    | (string | number)[]
                    | (string | number | ((...) | (...))[] | undefined)[]
                    | undefined,
            ) => void;
            toggle: (item: any) => void;
            updated: Ref<number, number>;
            updateVisibility: () => void;
            values: Set<any>;
            visible: Ref<boolean, boolean>;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        "update:model-value"[],
        "update:model-value",
        PublicProps,
        Readonly<
            ExtractPropTypes<
                {
                    buttonProps: { default: () => void; type: PropType<Partial<(...)>> };
                    clearable: { default: boolean; type: BooleanConstructor };
                    cols: { default: number; type: NumberConstructor };
                    disabled: { default: boolean; type: BooleanConstructor };
                    dropdownProps: { default: () => void; type: PropType<Partial<(...)>> };
                    hideOnClick: { default: boolean; type: BooleanConstructor };
                    items: { default: () => (...)[]; type: PropType<(...)[]> };
                    itemText: { default: string; type: PropType<(...) | (...)> };
                    itemValue: { default: string; type: PropType<(...) | (...)> };
                    modelValue: { type: PropType<(...) | (...) | (...)> };
                    multiple: { default: boolean; type: BooleanConstructor };
                    selection: { type: StringConstructor };
                },
            >,
        > & Readonly<{ "onUpdate:model-value"?: (...args: any[]) => any }>,
        {
            buttonProps: Partial<
                ExtractPropTypes<
                    {
                        block: { default: any; type: BooleanConstructor };
                        danger: { default: any; type: BooleanConstructor };
                        disabled: { default: any; type: BooleanConstructor };
                        ghost: { default: any; type: BooleanConstructor };
                        href: StringConstructor;
                        htmlType: { default: string; type: PropType<ButtonHTMLType> };
                        icon: VueTypeValidableDef<any>;
                        loading: {
                            default: () => (...) | (...);
                            type: PropType<(...) | (...)>;
                        };
                        onClick: { type: PropType<(event: ...) => ...> };
                        onMousedown: { type: PropType<(event: ...) => ...> };
                        prefixCls: StringConstructor;
                        shape: { type: PropType<ButtonShape> };
                        size: { type: PropType<ButtonSize> };
                        target: StringConstructor;
                        title: StringConstructor;
                        type: PropType<ButtonType>;
                    },
                >,
            >;
            clearable: boolean;
            cols: number;
            disabled: boolean;
            dropdownProps: Partial<
                ExtractPropTypes<
                    {
                        align: { type: PropType<Align> };
                        arrow: { default: any; type: PropType<(...) | (...)> };
                        destroyPopupOnHide: { default: any; type: BooleanConstructor };
                        disabled: { default: any; type: BooleanConstructor };
                        forceRender: { default: any; type: BooleanConstructor };
                        getPopupContainer: PropType<(triggerNode: HTMLElement) => HTMLElement>;
                        minOverlayWidthMatchTrigger: {
                            default: any;
                            type: BooleanConstructor;
                        };
                        mouseEnterDelay: NumberConstructor;
                        mouseLeaveDelay: NumberConstructor;
                        "onUpdate:visible": { type: PropType<(val: ...) => ...> };
                        onVisibleChange: { type: PropType<(val: ...) => ...> };
                        openClassName: StringConstructor;
                        overlay: VueTypeValidableDef<any>;
                        overlayClassName: StringConstructor;
                        overlayStyle: {
                            default: CSSProperties;
                            type: PropType<CSSProperties>;
                        };
                        placement: PropType<
                            | "bottom"
                            | "top"
                            | "bottomLeft"
                            | "bottomRight"
                            | "topLeft"
                            | "topRight"
                            | "topCenter"
                            | "bottomCenter",
                        >;
                        prefixCls: StringConstructor;
                        transitionName: StringConstructor;
                        trigger: { type: PropType<(...) | (...)> };
                        visible: { default: any; type: BooleanConstructor };
                    },
                >,
            >;
            hideOnClick: boolean;
            items: any[];
            itemText: string
            | ((item: any) => string);
            itemValue: string | ((item: any) => string | number);
            multiple: boolean;
        },
        {},
        { CloseCircleFilled: CloseCircleFilledIconType },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any,
    >;
} & GlobalComponents & Record<
    string,
    Component<any, any, any, ComputedOptions, MethodOptions, {}, any>,
>

`Static` `Optional`computed

computed?: {}

`Static` `Optional`data

data?: (
    this: CreateComponentPublicInstanceWithMixins<
        Readonly<
            ExtractPropTypes<
                {
                    buttonProps: {
                        type: PropType<Partial<ExtractPropTypes<(...)>>>;
                        default(): {};
                    };
                    clearable: { default: boolean; type: BooleanConstructor };
                    cols: {
                        default: () => {
                            day: number;
                            hour: number;
                            minute: number;
                            second: number;
                        };
                        type: PropType<Record<string, number>>;
                    };
                    customLocale: { type: PropType<Localization> };
                    disabled: { default: boolean; type: BooleanConstructor };
                    dropdownProps: {
                        default: () => void;
                        type: PropType<Partial<ExtractPropTypes<(...)>>>;
                    };
                    fields: { type: PropType<Field[]> };
                    format: { type: PropType<CronFormat> };
                    locale: { type: StringConstructor };
                    modelValue: { type: StringConstructor };
                    period: { type: StringConstructor };
                    periods: { type: PropType<Period[]> };
                },
            >,
        > & Readonly<
            {
                onError?: (...args: any[]) => any;
                "onUpdate:model-value"?: (...args: any[]) => any;
                "onUpdate:period"?: (...args: any[]) => any;
            },
        >,
        {},
        {},
        {},
        MethodOptions,
        ComponentOptionsMixin,
        ComponentOptionsMixin,
    >,
    vm: CreateComponentPublicInstanceWithMixins<
        Readonly<
            ExtractPropTypes<
                {
                    buttonProps: {
                        type: PropType<Partial<ExtractPropTypes<(...)>>>;
                        default(): {};
                    };
                    clearable: { default: boolean; type: BooleanConstructor };
                    cols: {
                        default: () => {
                            day: number;
                            hour: number;
                            minute: number;
                            second: number;
                        };
                        type: PropType<Record<string, number>>;
                    };
                    customLocale: { type: PropType<Localization> };
                    disabled: { default: boolean; type: BooleanConstructor };
                    dropdownProps: {
                        default: () => void;
                        type: PropType<Partial<ExtractPropTypes<(...)>>>;
                    };
                    fields: { type: PropType<Field[]> };
                    format: { type: PropType<CronFormat> };
                    locale: { type: StringConstructor };
                    modelValue: { type: StringConstructor };
                    period: { type: StringConstructor };
                    periods: { type: PropType<Period[]> };
                },
            >,
        > & Readonly<
            {
                onError?: (...args: any[]) => any;
                "onUpdate:model-value"?: (...args: any[]) => any;
                "onUpdate:period"?: (...args: any[]) => any;
            },
        >,
        {},
        {},
        {},
        MethodOptions,
        ComponentOptionsMixin,
        ComponentOptionsMixin,
    >,
) => {}

`Static` `Optional`delimiters

delimiters?: [string, string]

runtime compile only

Deprecated

use compilerOptions.delimiters instead.

`Static` `Optional`directives

directives?: GlobalDirectives & Record<string, Directive<any, any, string, any>>

`Static` `Optional`emits

emits?: ("update:model-value" | "update:period" | "error")[] & ThisType<void>

`Static` `Optional`errorCaptured

errorCaptured?: ErrorCapturedHook<unknown>

`Static` `Optional`expose

expose?: string[]

`Static` `Optional`extends

extends?: ComponentOptionsMixin

`Static` `Optional`filters

filters?: Record<string, Function>

`Static` `Optional`inheritAttrs

inheritAttrs?: boolean

`Static` `Optional`inject

inject?: {} | string[]

`Static` `Optional`key

key?: PropertyKey

`Static` `Optional`methods

methods?: {}

`Static` `Optional`mixins

mixins?: ComponentOptionsMixin[]

`Static` `Optional`name

name?: string

`Static` `Optional`onVnodeBeforeMount

onVnodeBeforeMount?: VNodeMountHook | VNodeMountHook[]

`Static` `Optional`onVnodeBeforeUnmount

onVnodeBeforeUnmount?: VNodeMountHook | VNodeMountHook[]

`Static` `Optional`onVnodeBeforeUpdate

onVnodeBeforeUpdate?: VNodeUpdateHook | VNodeUpdateHook[]

`Static` `Optional`onVnodeMounted

onVnodeMounted?: VNodeMountHook | VNodeMountHook[]

`Static` `Optional`onVnodeUnmounted

onVnodeUnmounted?: VNodeMountHook | VNodeMountHook[]

`Static` `Optional`onVnodeUpdated

onVnodeUpdated?: VNodeUpdateHook | VNodeUpdateHook[]

`Static` `Optional`provide

provide?: ComponentProvideOptions

`Static` `Optional`ref

ref?: VNodeRef

`Static` `Optional`ref_for

ref_for?: boolean

`Static` `Optional`ref_key

ref_key?: string

`Static` `Optional`render

render?: Function

`Static` `Optional`renderTracked

renderTracked?: DebuggerHook

`Static` `Optional`renderTriggered

renderTriggered?: DebuggerHook

`Static` `Optional`setup

setup?: (
    this: void,
    props: LooseRequired<
        Props & Prettify<
            UnwrapMixinsType<
                IntersectionMixin<Mixin> & IntersectionMixin<Extends>,
                "P",
            >,
        >,
    >,
    ctx: {
        attrs: Attrs;
        emit: (
            event: "update:model-value" | "update:period" | "error",
            ...args: any[],
        ) => void;
        expose: <Exposed extends Record<string, any> = Record<string, any>>(
            exposed?: Exposed,
        ) => void;
        slots: UnwrapSlotsType<S>;
    },
) => | void
| {
    cron: Ref<string, string>;
    error: Ref<string, string>;
    period: {
        items: { id: string; text: any; value: string[] }[];
        prefix: Ref<string, string>;
        select: (periodId: string) => void;
        selected: Ref<
            | { id: string; text?: string; value: string[] }
            | { id: string; text: any; value: string[] },

                | Period
                | { id: string; text: any; value: string[] }
                | { id: string; text?: string; value: string[] }
                | { id: string; text: any; value: string[] },
        >;
        suffix: Ref<string, string>;
    };
    segments: {
        cron: Ref<string, string>;
        error: Ref<string, string>;
        id: string;
        items: FieldItem[];
        prefix: Ref<string, string>;
        select: (evt: number[]) => void;
        selected: Ref<number[], number[]>;
        suffix: Ref<string, string>;
        text: Ref<string, string>;
    }[];
    selected: ComputedRef<
        {
            cron: Ref<string, string>;
            error: Ref<string, string>;
            id: string;
            items: FieldItem[];
            prefix: Ref<string, string>;
            select: (evt: number[]) => void;
            selected: Ref<number[], number[]>;
            suffix: Ref<string, string>;
            text: Ref<string, string>;
        }[],
    >;
}
| RenderFunction
| Promise<
    {
        cron: Ref<string, string>;
        error: Ref<string, string>;
        period: {
            items: { id: string; text: any; value: string[] }[];
            prefix: Ref<string, string>;
            select: (periodId: string) => void;
            selected: Ref<
                | { id: string; text?: string; value: string[] }
                | { id: string; text: any; value: string[] },

                    | Period
                    | { id: string; text: any; value: string[] }
                    | { id: string; text?: string; value: string[] }
                    | { id: string; text: any; value: string[] },
            >;
            suffix: Ref<string, string>;
        };
        segments: {
            cron: Ref<string, string>;
            error: Ref<string, string>;
            id: string;
            items: FieldItem[];
            prefix: Ref<string, string>;
            select: (evt: number[]) => void;
            selected: Ref<number[], number[]>;
            suffix: Ref<string, string>;
            text: Ref<string, string>;
        }[];
        selected: ComputedRef<
            {
                cron: Ref<string, string>;
                error: Ref<string, string>;
                id: string;
                items: FieldItem[];
                prefix: Ref<string, string>;
                select: (evt: number[]) => void;
                selected: Ref<number[], number[]>;
                suffix: Ref<string, string>;
                text: Ref<string, string>;
            }[],
        >;
    },
>

`Static` `Optional`slots

slots?: {}

`Static` `Optional`style

style?: unknown

`Static` `Optional`template

template?: string | object

`Static` `Optional`watch

watch?: ComponentWatchOptions

Methods

$watch

$watch<T extends string | ((...args: any) => any)>(
    source: T,
    cb: T extends (...args: any) => R
        ? (...args: [R, R, OnCleanup]) => any
        : (...args: [any, any, OnCleanup]) => any,
    options?: WatchOptions<boolean>,
): WatchStopHandle
Type Parameters
- T extends string | ((...args: any) => any)
Parameters
- source: T
- cb: T extends (...args: any) => R
  ? (...args: [R, R, OnCleanup]) => any
  : (...args: [any, any, OnCleanup]) => any
- Optionaloptions: WatchOptions<boolean>
Returns WatchStopHandle
- Defined in node_modules/@vue/runtime-core/dist/runtime-core.d.ts:521

`Static` `Optional`activated

activated?(): any
Returns any
- Defined in node_modules/@vue/runtime-core/dist/runtime-core.d.ts:907

`Static` `Optional`beforeCreate

beforeCreate?(): any
Returns any
- Defined in node_modules/@vue/runtime-core/dist/runtime-core.d.ts:901

`Static` `Optional`beforeDestroy

beforeDestroy?(): any
Returns any

Deprecated
use beforeUnmount instead
- Defined in node_modules/@vue/runtime-core/dist/runtime-core.d.ts:910

`Static` `Optional`beforeMount

beforeMount?(): any
Returns any
- Defined in node_modules/@vue/runtime-core/dist/runtime-core.d.ts:903

`Static` `Optional`beforeUnmount

beforeUnmount?(): any
Returns any
- Defined in node_modules/@vue/runtime-core/dist/runtime-core.d.ts:911

`Static` `Optional`beforeUpdate

beforeUpdate?(): any
Returns any
- Defined in node_modules/@vue/runtime-core/dist/runtime-core.d.ts:905

`Static` `Optional`created

created?(): any
Returns any
- Defined in node_modules/@vue/runtime-core/dist/runtime-core.d.ts:902

`Static` `Optional`deactivated

deactivated?(): any
Returns any
- Defined in node_modules/@vue/runtime-core/dist/runtime-core.d.ts:908

`Static` `Optional`destroyed

destroyed?(): any
Returns any

Deprecated
use unmounted instead
- Defined in node_modules/@vue/runtime-core/dist/runtime-core.d.ts:913

`Static` `Optional`mounted

mounted?(): any
Returns any
- Defined in node_modules/@vue/runtime-core/dist/runtime-core.d.ts:904

`Static` `Optional`serverPrefetch

serverPrefetch?(): void | Promise<any>
Returns void | Promise<any>
- Defined in node_modules/@vue/runtime-core/dist/runtime-core.d.ts:843

`Static` `Optional`unmounted

unmounted?(): any
Returns any
- Defined in node_modules/@vue/runtime-core/dist/runtime-core.d.ts:914

`Static` `Optional`updated

updated?(): any
Returns any
- Defined in node_modules/@vue/runtime-core/dist/runtime-core.d.ts:906

Class CronAnt

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

Returns CronAnt

Properties

$

$attrs

$data

$el

$emit

$forceUpdate

$host

$nextTick

$options

$parent

$props

$refs

$root

$slots

ReadonlybuttonProps

Readonlyclearable

Readonlycols

cron

Optional ReadonlycustomLocale

Readonlydisabled

ReadonlydropdownProps

error

Optional Readonlyfields

Optional Readonlyformat

Optional Readonlylocale

Optional ReadonlymodelValue

Optional ReadonlyonError

Optional ReadonlyonUpdate:model-value

Optional ReadonlyonUpdate:period

period

Optional Readonlyperiods

segments

selected

Static Optional__defaults

Static Optional__differentiator

Static Optional__file

Static Optional__isBuiltIn

Static Optional__isFragment

Static Optional__isSuspense

Static Optional__isTeleport

Static Optional__name

Static Optionalcall

Static Optionalclass

Static OptionalcompatConfig

Static OptionalcompilerOptions

Static Optionalcomponents

Static Optionalcomputed

Static Optionaldata

Static Optionaldelimiters

Deprecated

Static Optionaldirectives

Static Optionalemits

Static OptionalerrorCaptured

Static Optionalexpose

Static Optionalextends

Static Optionalfilters

Static OptionalinheritAttrs

Static Optionalinject

Static Optionalkey

Static Optionalmethods

Static Optionalmixins

Static Optionalname

Static OptionalonVnodeBeforeMount

Static OptionalonVnodeBeforeUnmount

Static OptionalonVnodeBeforeUpdate

Static OptionalonVnodeMounted

Static OptionalonVnodeUnmounted

Static OptionalonVnodeUpdated

Static Optionalprovide

Static Optionalref

`Readonly`buttonProps

`Readonly`clearable

`Readonly`cols

`Optional` `Readonly`customLocale

`Readonly`disabled

`Readonly`dropdownProps

`Optional` `Readonly`fields

`Optional` `Readonly`format

`Optional` `Readonly`locale

`Optional` `Readonly`modelValue

`Optional` `Readonly`onError

`Optional` `Readonly`onUpdate:model-value

`Optional` `Readonly`onUpdate:period

`Optional` `Readonly`periods

`Static` `Optional`__defaults

`Static` `Optional`__differentiator

`Static` `Optional`__file

`Static` `Optional`__isBuiltIn

`Static` `Optional`__isFragment

`Static` `Optional`__isSuspense

`Static` `Optional`__isTeleport

`Static` `Optional`__name

`Static` `Optional`call

`Static` `Optional`class

`Static` `Optional`compatConfig

`Static` `Optional`compilerOptions

`Static` `Optional`components

`Static` `Optional`computed

`Static` `Optional`data

`Static` `Optional`delimiters

`Static` `Optional`directives

`Static` `Optional`emits

`Static` `Optional`errorCaptured

`Static` `Optional`expose

`Static` `Optional`extends

`Static` `Optional`filters

`Static` `Optional`inheritAttrs

`Static` `Optional`inject

`Static` `Optional`key

`Static` `Optional`methods

`Static` `Optional`mixins

`Static` `Optional`name

`Static` `Optional`onVnodeBeforeMount

`Static` `Optional`onVnodeBeforeUnmount

`Static` `Optional`onVnodeBeforeUpdate

`Static` `Optional`onVnodeMounted

`Static` `Optional`onVnodeUnmounted

`Static` `Optional`onVnodeUpdated

`Static` `Optional`provide

`Static` `Optional`ref

`Static` `Optional`ref_for

`Static` `Optional`ref_key

`Static` `Optional`render

`Static` `Optional`renderTracked

`Static` `Optional`renderTriggered

`Static` `Optional`setup

`Static` `Optional`slots

`Static` `Optional`style

`Static` `Optional`template

`Static` `Optional`watch

`Static` `Optional`activated

`Static` `Optional`beforeCreate

`Static` `Optional`beforeDestroy

`Static` `Optional`beforeMount

`Static` `Optional`beforeUnmount

`Static` `Optional`beforeUpdate

`Static` `Optional`created

`Static` `Optional`deactivated

`Static` `Optional`destroyed

`Static` `Optional`mounted

`Static` `Optional`serverPrefetch

`Static` `Optional`unmounted

`Static` `Optional`updated