Class CronElementPlus

Index

Constructors

Methods

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

Constructors

constructor

new CronElementPlus(...args: any[]): CronElementPlus
Parameters
- ...args: any[]
Returns CronElementPlus
- 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: ObjectConstructor; 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: ObjectConstructor };
                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: Record<string, any>;
        clearable: boolean;
        cols: Record<string, number>;
        disabled: boolean;
        dropdownProps: Record<string, any>;
    },
    {},
    string,
    {},
    {
        CustomSelect: DefineComponent<
            ExtractPropTypes<
                {
                    buttonProps: { default: () => void; type: ObjectConstructor };
                    clearable: { default: boolean; type: BooleanConstructor };
                    cols: { default: number; type: NumberConstructor };
                    disabled: { default: boolean; type: BooleanConstructor };
                    dropdownProps: { default: () => void; type: ObjectConstructor };
                    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,
                >;
                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>;
                values: Set<any>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            "update:model-value"[],
            "update:model-value",
            PublicProps,
            Readonly<
                ExtractPropTypes<
                    {
                        buttonProps: { default: () => ...; type: ObjectConstructor };
                        clearable: { default: boolean; type: BooleanConstructor };
                        cols: { default: number; type: NumberConstructor };
                        disabled: { default: boolean; type: BooleanConstructor };
                        dropdownProps: { default: () => ...; type: ObjectConstructor };
                        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: Record<string, any>;
                clearable: boolean;
                cols: number;
                disabled: boolean;
                dropdownProps: Record<string, any>;
                items: any[];
                itemText: string | ((item: any) => string);
                itemValue: string | ((item: any) => string | number);
                multiple: boolean;
            },
            {},
            {
                Close: DefineComponent<
                    {},
                    void,
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<{}>,
                    {},
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any,
                >;
            },
            {},
            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: Record<string, any>;
        clearable: boolean;
        cols: Record<string, number>;
        disabled: boolean;
        dropdownProps: Record<string, any>;
    },
> & Omit<
    {
        buttonProps: Record<string, any>;
        clearable: boolean;
        cols: Record<string, number>;
        customLocale?: Localization;
        disabled: boolean;
        dropdownProps: Record<string, any>;
        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: Record<string, any>

`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: Record<string, any>

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: Record<string, any>;
    clearable: boolean;
    cols: Record<string, number>;
    disabled: boolean;
    dropdownProps: Record<string, any>;
}

`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: ObjectConstructor };
                clearable: { default: boolean; type: BooleanConstructor };
                cols: { default: number; type: NumberConstructor };
                disabled: { default: boolean; type: BooleanConstructor };
                dropdownProps: { default: () => void; type: ObjectConstructor };
                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,
            >;
            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>;
            values: Set<any>;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        "update:model-value"[],
        "update:model-value",
        PublicProps,
        Readonly<
            ExtractPropTypes<
                {
                    buttonProps: { default: () => void; type: ObjectConstructor };
                    clearable: { default: boolean; type: BooleanConstructor };
                    cols: { default: number; type: NumberConstructor };
                    disabled: { default: boolean; type: BooleanConstructor };
                    dropdownProps: { default: () => void; type: ObjectConstructor };
                    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: Record<string, any>;
            clearable: boolean;
            cols: number;
            disabled: boolean;
            dropdownProps: Record<string, any>;
            items: any[];
            itemText: string | ((item: any) => string);
            itemValue: string | ((item: any) => string | number);
            multiple: boolean;
        },
        {},
        {
            Close: DefineComponent<
                {},
                void,
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<{}>,
                {},
                {},
                {},
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any,
            >;
        },
        {},
        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: ObjectConstructor; 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: ObjectConstructor };
                    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: ObjectConstructor; 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: ObjectConstructor };
                    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 CronElementPlus

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

Returns CronElementPlus

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