import { GpuQuotaItem, type VgpuSchedulePolicy } from '../types';
import '../style/gpu-form';
declare const _default: import("vue").DefineComponent<{
    gpuSettingsAdaptor: {
        type: import("vue").PropType<import("../props").GPUSettings>;
        default: undefined;
    };
    nvidiaVgpuModelsAdaptor: {
        type: import("vue").PropType<{
            data: import("../types").GPUSummary[];
            loading: boolean;
            refresh: () => import("../types").GPUSummary[] | Promise<import("../types").GPUSummary[]>;
        }>;
        default: undefined;
    };
    nvidiaVgpuDevicesAdaptor: {
        type: import("vue").PropType<import("../props").GpuDevicesAdaptor>;
        default: undefined;
    };
    targetType: {
        type: StringConstructor;
        default: string;
    };
    enableRemoteCall: {
        type: BooleanConstructor;
        default: boolean;
    };
    enableRangeValidate: {
        type: BooleanConstructor;
        default: boolean;
    };
    enableNvidiaVgpuModel: {
        type: BooleanConstructor;
        default: boolean;
    };
    nvidiaVgpuModel: {
        type: StringConstructor;
        default: undefined;
    };
    enableNvidiaVgpuDevices: {
        type: BooleanConstructor;
        default: boolean;
    };
    nvidiaVgpuDevices: {
        type: import("vue").PropType<string[]>;
        default: () => never[];
    };
    enableNvidiaVgpuPriority: {
        type: BooleanConstructor;
        default: boolean;
    };
    nvidiaVgpuPriority: {
        type: import("vue").PropType<"0" | "1">;
        default: undefined;
    };
    dynamicLimitOne: {
        type: BooleanConstructor;
        default: boolean;
    };
    enableNvidiaVgpuSchedulePolicy: {
        type: BooleanConstructor;
        default: boolean;
    };
    nvidiaVgpuGpuSchedule: {
        type: import("vue").PropType<VgpuSchedulePolicy>;
        default: undefined;
    };
    nvidiaVgpuNodeSchedule: {
        type: import("vue").PropType<VgpuSchedulePolicy>;
        default: undefined;
    };
    quota: {
        type: import("vue").PropType<import("../types").GpuQuota>;
        default: () => {
            types: never[];
            resources: {};
        };
    };
    formWidth: {
        type: StringConstructor;
        default: undefined;
    };
    usedQuota: {
        type: import("vue").PropType<import("../types").GpuQuota>;
        default: undefined;
    };
    availableQuota: {
        type: import("vue").PropType<import("../types").GpuQuota>;
        default: undefined;
    };
    withPrefixRequest: {
        type: BooleanConstructor;
        default: boolean;
    };
    limit: {
        type: NumberConstructor;
        default: undefined;
    };
}, {
    isLimitOne: import("vue").ComputedRef<boolean>;
    rows: import("vue").Ref<{
        type?: string | undefined;
        id?: string | undefined;
        removable?: boolean | undefined;
        resources?: Record<string, string | number | undefined> | undefined;
        nvidiaVgpuModel?: string | undefined;
        nvidiaVgpuDevices?: string[] | undefined;
        nvidiaVgpPriority?: string | undefined;
        nvidiaVgpuGpuSchedule?: VgpuSchedulePolicy | undefined;
        nvidiaVgpuNodeSchedule?: VgpuSchedulePolicy | undefined;
    }[]>;
    rowsRef: import("vue").Ref<({
        $: import("vue").ComponentInternalInstance;
        $data: {};
        $props: Partial<{
            nvidiaVgpuModel: string;
            nvidiaVgpuDevices: string[];
            nvidiaVgpuGpuSchedule: VgpuSchedulePolicy;
            nvidiaVgpuNodeSchedule: VgpuSchedulePolicy;
            gpuSettingsAdaptor: import("../props").GPUSettings;
            nvidiaVgpuModelsAdaptor: {
                data: import("../types").GPUSummary[];
                loading: boolean;
                refresh: () => import("../types").GPUSummary[] | Promise<import("../types").GPUSummary[]>;
            };
            nvidiaVgpuDevicesAdaptor: import("../props").GpuDevicesAdaptor;
            targetType: string;
            enableRemoteCall: boolean;
            enableRangeValidate: boolean;
            enableNvidiaVgpuModel: boolean;
            enableNvidiaVgpuDevices: boolean;
            enableNvidiaVgpuPriority: boolean;
            nvidiaVgpuPriority: "0" | "1";
            dynamicLimitOne: boolean;
            enableNvidiaVgpuSchedulePolicy: boolean;
            quotaItem: GpuQuotaItem;
            isSide: boolean;
            availableQuotaItem: GpuQuotaItem;
            usedQuotaItem: GpuQuotaItem;
            existTypes: string[];
            nvidiaGpuDevices: import("../props").GpuDevice[];
        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
            gpuSettingsAdaptor: {
                type: import("vue").PropType<import("../props").GPUSettings>;
                default: undefined;
            };
            nvidiaVgpuModelsAdaptor: {
                type: import("vue").PropType<{
                    data: import("../types").GPUSummary[];
                    loading: boolean;
                    refresh: () => import("../types").GPUSummary[] | Promise<import("../types").GPUSummary[]>;
                }>;
                default: undefined;
            };
            nvidiaVgpuDevicesAdaptor: {
                type: import("vue").PropType<import("../props").GpuDevicesAdaptor>;
                default: undefined;
            };
            targetType: {
                type: StringConstructor;
                default: string;
            };
            enableRemoteCall: {
                type: BooleanConstructor;
                default: boolean;
            };
            enableRangeValidate: {
                type: BooleanConstructor;
                default: boolean;
            };
            enableNvidiaVgpuModel: {
                type: BooleanConstructor;
                default: boolean;
            };
            nvidiaVgpuModel: {
                type: StringConstructor;
                default: undefined;
            };
            enableNvidiaVgpuDevices: {
                type: BooleanConstructor;
                default: boolean;
            };
            nvidiaVgpuDevices: {
                type: import("vue").PropType<string[]>;
                default: () => never[];
            };
            enableNvidiaVgpuPriority: {
                type: BooleanConstructor;
                default: boolean;
            };
            nvidiaVgpuPriority: {
                type: import("vue").PropType<"0" | "1">;
                default: undefined;
            };
            dynamicLimitOne: {
                type: BooleanConstructor;
                default: boolean;
            };
            enableNvidiaVgpuSchedulePolicy: {
                type: BooleanConstructor;
                default: boolean;
            };
            nvidiaVgpuGpuSchedule: {
                type: import("vue").PropType<VgpuSchedulePolicy>;
                default: undefined;
            };
            nvidiaVgpuNodeSchedule: {
                type: import("vue").PropType<VgpuSchedulePolicy>;
                default: undefined;
            };
            quotaItem: {
                type: import("vue").PropType<GpuQuotaItem>;
                default: () => {};
            };
            isSide: {
                type: BooleanConstructor;
                default: boolean;
            };
            availableQuotaItem: {
                type: import("vue").PropType<GpuQuotaItem>;
                default: undefined;
            };
            usedQuotaItem: {
                type: import("vue").PropType<GpuQuotaItem>;
                default: undefined;
            };
            existTypes: {
                type: import("vue").PropType<string[]>;
                default: () => never[];
            };
            gpuOptionsMap: {
                type: import("vue").PropType<Map<string, import("../types").GPUSetting>>;
                required: boolean;
            };
            nvidiaGpuModels: {
                type: import("vue").PropType<string[]>;
                required: boolean;
            };
            getDisplayResource: {
                type: import("vue").PropType<(type: string) => import("../types").GPUResourceSetting[]>;
                required: boolean;
            };
            nvidiaGpuDevices: {
                type: import("vue").PropType<import("../props").GpuDevice[]>;
                default: () => never[];
            };
        }>> & {
            onChange?: ((...args: any[]) => any) | undefined;
            "onUpdate:quotaItem"?: ((...args: any[]) => any) | undefined;
            onRefreshGpuOptionsMap?: ((...args: any[]) => any) | undefined;
        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "nvidiaVgpuModel" | "nvidiaVgpuDevices" | "nvidiaVgpuGpuSchedule" | "nvidiaVgpuNodeSchedule" | "gpuSettingsAdaptor" | "nvidiaVgpuModelsAdaptor" | "nvidiaVgpuDevicesAdaptor" | "targetType" | "enableRemoteCall" | "enableRangeValidate" | "enableNvidiaVgpuModel" | "enableNvidiaVgpuDevices" | "enableNvidiaVgpuPriority" | "nvidiaVgpuPriority" | "dynamicLimitOne" | "enableNvidiaVgpuSchedulePolicy" | "quotaItem" | "isSide" | "availableQuotaItem" | "usedQuotaItem" | "existTypes" | "nvidiaGpuDevices">;
        $attrs: {
            [x: string]: unknown;
        };
        $refs: {
            [x: string]: unknown;
        };
        $slots: Readonly<{
            [name: string]: import("vue").Slot | undefined;
        }>;
        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
        $emit: (event: "change" | "update:quotaItem" | "refreshGpuOptionsMap", ...args: any[]) => void;
        $el: any;
        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
            gpuSettingsAdaptor: {
                type: import("vue").PropType<import("../props").GPUSettings>;
                default: undefined;
            };
            nvidiaVgpuModelsAdaptor: {
                type: import("vue").PropType<{
                    data: import("../types").GPUSummary[];
                    loading: boolean;
                    refresh: () => import("../types").GPUSummary[] | Promise<import("../types").GPUSummary[]>;
                }>;
                default: undefined;
            };
            nvidiaVgpuDevicesAdaptor: {
                type: import("vue").PropType<import("../props").GpuDevicesAdaptor>;
                default: undefined;
            };
            targetType: {
                type: StringConstructor;
                default: string;
            };
            enableRemoteCall: {
                type: BooleanConstructor;
                default: boolean;
            };
            enableRangeValidate: {
                type: BooleanConstructor;
                default: boolean;
            };
            enableNvidiaVgpuModel: {
                type: BooleanConstructor;
                default: boolean;
            };
            nvidiaVgpuModel: {
                type: StringConstructor;
                default: undefined;
            };
            enableNvidiaVgpuDevices: {
                type: BooleanConstructor;
                default: boolean;
            };
            nvidiaVgpuDevices: {
                type: import("vue").PropType<string[]>;
                default: () => never[];
            };
            enableNvidiaVgpuPriority: {
                type: BooleanConstructor;
                default: boolean;
            };
            nvidiaVgpuPriority: {
                type: import("vue").PropType<"0" | "1">;
                default: undefined;
            };
            dynamicLimitOne: {
                type: BooleanConstructor;
                default: boolean;
            };
            enableNvidiaVgpuSchedulePolicy: {
                type: BooleanConstructor;
                default: boolean;
            };
            nvidiaVgpuGpuSchedule: {
                type: import("vue").PropType<VgpuSchedulePolicy>;
                default: undefined;
            };
            nvidiaVgpuNodeSchedule: {
                type: import("vue").PropType<VgpuSchedulePolicy>;
                default: undefined;
            };
            quotaItem: {
                type: import("vue").PropType<GpuQuotaItem>;
                default: () => {};
            };
            isSide: {
                type: BooleanConstructor;
                default: boolean;
            };
            availableQuotaItem: {
                type: import("vue").PropType<GpuQuotaItem>;
                default: undefined;
            };
            usedQuotaItem: {
                type: import("vue").PropType<GpuQuotaItem>;
                default: undefined;
            };
            existTypes: {
                type: import("vue").PropType<string[]>;
                default: () => never[];
            };
            gpuOptionsMap: {
                type: import("vue").PropType<Map<string, import("../types").GPUSetting>>;
                required: boolean;
            };
            nvidiaGpuModels: {
                type: import("vue").PropType<string[]>;
                required: boolean;
            };
            getDisplayResource: {
                type: import("vue").PropType<(type: string) => import("../types").GPUResourceSetting[]>;
                required: boolean;
            };
            nvidiaGpuDevices: {
                type: import("vue").PropType<import("../props").GpuDevice[]>;
                default: () => never[];
            };
        }>> & {
            onChange?: ((...args: any[]) => any) | undefined;
            "onUpdate:quotaItem"?: ((...args: any[]) => any) | undefined;
            onRefreshGpuOptionsMap?: ((...args: any[]) => any) | undefined;
        }, {
            quota: GpuQuotaItem;
            dynamicQuota: import("vue").Ref<Record<string, string | number | undefined> | undefined>;
            currentDisplayResource: import("vue").ComputedRef<import("../types").GPUResourceSetting[] | undefined>;
            filteredGpuOptionsMap: import("vue").ComputedRef<Map<string, import("../types").GPUSetting>>;
            getGPUTypeInSide: (quotaType?: string | undefined) => string;
            handleTypeChange: (val: unknown) => void;
            validate: () => Promise<import("vee-validate").FormValidationResult<GpuQuotaItem>> | {
                valid: boolean;
            };
            nvidiaVgpuModelKey: string;
            nvidiaVgpuPriorityKey: string;
            nvidiaVgpuKey: string;
            nvidiaVgpuResOrder: Map<string, string>;
            yup: typeof import("yup");
            deSanitizeGPUObjectKey: <T extends Record<string, unknown>>(obj?: T | undefined) => T;
            gpuResourceHelperSlot: () => string[] | undefined;
            openNvidiaVgpuModel: import("vue").Ref<boolean>;
            openNvidiaAssignGpu: import("vue").Ref<boolean>;
            openNvidiaVgpuSchedulePolicy: import("vue").Ref<boolean>;
            isNvidiaVgpu: (key?: string | undefined) => boolean;
            isNvidiaMig: (key?: string | undefined) => boolean;
            showDynamicForm: import("vue").ComputedRef<boolean | undefined>;
        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:quotaItem" | "refreshGpuOptionsMap")[], string, {
            nvidiaVgpuModel: string;
            nvidiaVgpuDevices: string[];
            nvidiaVgpuGpuSchedule: VgpuSchedulePolicy;
            nvidiaVgpuNodeSchedule: VgpuSchedulePolicy;
            gpuSettingsAdaptor: import("../props").GPUSettings;
            nvidiaVgpuModelsAdaptor: {
                data: import("../types").GPUSummary[];
                loading: boolean;
                refresh: () => import("../types").GPUSummary[] | Promise<import("../types").GPUSummary[]>;
            };
            nvidiaVgpuDevicesAdaptor: import("../props").GpuDevicesAdaptor;
            targetType: string;
            enableRemoteCall: boolean;
            enableRangeValidate: boolean;
            enableNvidiaVgpuModel: boolean;
            enableNvidiaVgpuDevices: boolean;
            enableNvidiaVgpuPriority: boolean;
            nvidiaVgpuPriority: "0" | "1";
            dynamicLimitOne: boolean;
            enableNvidiaVgpuSchedulePolicy: boolean;
            quotaItem: GpuQuotaItem;
            isSide: boolean;
            availableQuotaItem: GpuQuotaItem;
            usedQuotaItem: GpuQuotaItem;
            existTypes: string[];
            nvidiaGpuDevices: import("../props").GpuDevice[];
        }, {}, string> & {
            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
            created?: ((() => void) | (() => void)[]) | undefined;
            beforeMount?: ((() => void) | (() => void)[]) | undefined;
            mounted?: ((() => void) | (() => void)[]) | undefined;
            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
            updated?: ((() => void) | (() => void)[]) | undefined;
            activated?: ((() => void) | (() => void)[]) | undefined;
            deactivated?: ((() => void) | (() => void)[]) | undefined;
            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
            destroyed?: ((() => void) | (() => void)[]) | undefined;
            unmounted?: ((() => void) | (() => void)[]) | undefined;
            renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
            renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
            errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
        };
        $forceUpdate: () => void;
        $nextTick: typeof import("vue").nextTick;
        $watch<T_1 extends string | ((...args: any) => any)>(source: T_1, cb: T_1 extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
    } & Readonly<import("vue").ExtractPropTypes<{
        gpuSettingsAdaptor: {
            type: import("vue").PropType<import("../props").GPUSettings>;
            default: undefined;
        };
        nvidiaVgpuModelsAdaptor: {
            type: import("vue").PropType<{
                data: import("../types").GPUSummary[];
                loading: boolean;
                refresh: () => import("../types").GPUSummary[] | Promise<import("../types").GPUSummary[]>;
            }>;
            default: undefined;
        };
        nvidiaVgpuDevicesAdaptor: {
            type: import("vue").PropType<import("../props").GpuDevicesAdaptor>;
            default: undefined;
        };
        targetType: {
            type: StringConstructor;
            default: string;
        };
        enableRemoteCall: {
            type: BooleanConstructor;
            default: boolean;
        };
        enableRangeValidate: {
            type: BooleanConstructor;
            default: boolean;
        };
        enableNvidiaVgpuModel: {
            type: BooleanConstructor;
            default: boolean;
        };
        nvidiaVgpuModel: {
            type: StringConstructor;
            default: undefined;
        };
        enableNvidiaVgpuDevices: {
            type: BooleanConstructor;
            default: boolean;
        };
        nvidiaVgpuDevices: {
            type: import("vue").PropType<string[]>;
            default: () => never[];
        };
        enableNvidiaVgpuPriority: {
            type: BooleanConstructor;
            default: boolean;
        };
        nvidiaVgpuPriority: {
            type: import("vue").PropType<"0" | "1">;
            default: undefined;
        };
        dynamicLimitOne: {
            type: BooleanConstructor;
            default: boolean;
        };
        enableNvidiaVgpuSchedulePolicy: {
            type: BooleanConstructor;
            default: boolean;
        };
        nvidiaVgpuGpuSchedule: {
            type: import("vue").PropType<VgpuSchedulePolicy>;
            default: undefined;
        };
        nvidiaVgpuNodeSchedule: {
            type: import("vue").PropType<VgpuSchedulePolicy>;
            default: undefined;
        };
        quotaItem: {
            type: import("vue").PropType<GpuQuotaItem>;
            default: () => {};
        };
        isSide: {
            type: BooleanConstructor;
            default: boolean;
        };
        availableQuotaItem: {
            type: import("vue").PropType<GpuQuotaItem>;
            default: undefined;
        };
        usedQuotaItem: {
            type: import("vue").PropType<GpuQuotaItem>;
            default: undefined;
        };
        existTypes: {
            type: import("vue").PropType<string[]>;
            default: () => never[];
        };
        gpuOptionsMap: {
            type: import("vue").PropType<Map<string, import("../types").GPUSetting>>;
            required: boolean;
        };
        nvidiaGpuModels: {
            type: import("vue").PropType<string[]>;
            required: boolean;
        };
        getDisplayResource: {
            type: import("vue").PropType<(type: string) => import("../types").GPUResourceSetting[]>;
            required: boolean;
        };
        nvidiaGpuDevices: {
            type: import("vue").PropType<import("../props").GpuDevice[]>;
            default: () => never[];
        };
    }>> & {
        onChange?: ((...args: any[]) => any) | undefined;
        "onUpdate:quotaItem"?: ((...args: any[]) => any) | undefined;
        onRefreshGpuOptionsMap?: ((...args: any[]) => any) | undefined;
    } & import("vue").ShallowUnwrapRef<{
        quota: GpuQuotaItem;
        dynamicQuota: import("vue").Ref<Record<string, string | number | undefined> | undefined>;
        currentDisplayResource: import("vue").ComputedRef<import("../types").GPUResourceSetting[] | undefined>;
        filteredGpuOptionsMap: import("vue").ComputedRef<Map<string, import("../types").GPUSetting>>;
        getGPUTypeInSide: (quotaType?: string | undefined) => string;
        handleTypeChange: (val: unknown) => void;
        validate: () => Promise<import("vee-validate").FormValidationResult<GpuQuotaItem>> | {
            valid: boolean;
        };
        nvidiaVgpuModelKey: string;
        nvidiaVgpuPriorityKey: string;
        nvidiaVgpuKey: string;
        nvidiaVgpuResOrder: Map<string, string>;
        yup: typeof import("yup");
        deSanitizeGPUObjectKey: <T extends Record<string, unknown>>(obj?: T | undefined) => T;
        gpuResourceHelperSlot: () => string[] | undefined;
        openNvidiaVgpuModel: import("vue").Ref<boolean>;
        openNvidiaAssignGpu: import("vue").Ref<boolean>;
        openNvidiaVgpuSchedulePolicy: import("vue").Ref<boolean>;
        isNvidiaVgpu: (key?: string | undefined) => boolean;
        isNvidiaMig: (key?: string | undefined) => boolean;
        showDynamicForm: import("vue").ComputedRef<boolean | undefined>;
    }> & {} & import("vue").ComponentCustomProperties & {})[]>;
    existTypes: import("vue").ComputedRef<string[]>;
    handleRowChange: (idx: number, newRow: GpuQuotaItem) => void;
    handleAdd: () => void;
    handleDeleteRow: (idx: number) => void;
    enableGpu: import("vue").WritableComputedRef<boolean>;
    gpuOptionsMap: import("vue").Ref<Map<string, import("../types").GPUSetting>>;
    fetchGpuOptions: () => Promise<import("../types").GPUSetting[] | undefined>;
    getDisplayResource: (type: string) => import("../types").GPUResourceSetting[];
    nvidiaGpuModels: import("vue").Ref<string[]>;
    showSide: import("vue").ComputedRef<boolean>;
    sideRows: import("vue").Ref<{
        type?: string | undefined;
        id?: string | undefined;
        removable?: boolean | undefined;
        resources?: Record<string, string | number | undefined> | undefined;
        nvidiaVgpuModel?: string | undefined;
        nvidiaVgpuDevices?: string[] | undefined;
        nvidiaVgpPriority?: string | undefined;
        nvidiaVgpuGpuSchedule?: VgpuSchedulePolicy | undefined;
        nvidiaVgpuNodeSchedule?: VgpuSchedulePolicy | undefined;
    }[]>;
    validate: () => Promise<boolean>;
    getUsedQuotaItem: (index: number) => {
        type?: string | undefined;
        id?: string | undefined;
        removable?: boolean | undefined;
        resources?: Record<string, string | number | undefined> | undefined;
        nvidiaVgpuModel?: string | undefined;
        nvidiaVgpuDevices?: string[] | undefined;
        nvidiaVgpPriority?: string | undefined;
        nvidiaVgpuGpuSchedule?: VgpuSchedulePolicy | undefined;
        nvidiaVgpuNodeSchedule?: VgpuSchedulePolicy | undefined;
    } | undefined;
    getAvailableQuotaItem: (index: number) => {
        type?: string | undefined;
        id?: string | undefined;
        removable?: boolean | undefined;
        resources?: Record<string, string | number | undefined> | undefined;
        nvidiaVgpuModel?: string | undefined;
        nvidiaVgpuDevices?: string[] | undefined;
        nvidiaVgpPriority?: string | undefined;
        nvidiaVgpuGpuSchedule?: VgpuSchedulePolicy | undefined;
        nvidiaVgpuNodeSchedule?: VgpuSchedulePolicy | undefined;
    } | undefined;
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:nvidiaVgpuModel" | "update:nvidiaVgpuPriority" | "update:nvidiaVgpuGpuSchedule" | "update:nvidiaVgpuNodeSchedule" | "update:nvidiaVgpuDevices")[], "change" | "update:nvidiaVgpuModel" | "update:nvidiaVgpuPriority" | "update:nvidiaVgpuGpuSchedule" | "update:nvidiaVgpuNodeSchedule" | "update:nvidiaVgpuDevices", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
    gpuSettingsAdaptor: {
        type: import("vue").PropType<import("../props").GPUSettings>;
        default: undefined;
    };
    nvidiaVgpuModelsAdaptor: {
        type: import("vue").PropType<{
            data: import("../types").GPUSummary[];
            loading: boolean;
            refresh: () => import("../types").GPUSummary[] | Promise<import("../types").GPUSummary[]>;
        }>;
        default: undefined;
    };
    nvidiaVgpuDevicesAdaptor: {
        type: import("vue").PropType<import("../props").GpuDevicesAdaptor>;
        default: undefined;
    };
    targetType: {
        type: StringConstructor;
        default: string;
    };
    enableRemoteCall: {
        type: BooleanConstructor;
        default: boolean;
    };
    enableRangeValidate: {
        type: BooleanConstructor;
        default: boolean;
    };
    enableNvidiaVgpuModel: {
        type: BooleanConstructor;
        default: boolean;
    };
    nvidiaVgpuModel: {
        type: StringConstructor;
        default: undefined;
    };
    enableNvidiaVgpuDevices: {
        type: BooleanConstructor;
        default: boolean;
    };
    nvidiaVgpuDevices: {
        type: import("vue").PropType<string[]>;
        default: () => never[];
    };
    enableNvidiaVgpuPriority: {
        type: BooleanConstructor;
        default: boolean;
    };
    nvidiaVgpuPriority: {
        type: import("vue").PropType<"0" | "1">;
        default: undefined;
    };
    dynamicLimitOne: {
        type: BooleanConstructor;
        default: boolean;
    };
    enableNvidiaVgpuSchedulePolicy: {
        type: BooleanConstructor;
        default: boolean;
    };
    nvidiaVgpuGpuSchedule: {
        type: import("vue").PropType<VgpuSchedulePolicy>;
        default: undefined;
    };
    nvidiaVgpuNodeSchedule: {
        type: import("vue").PropType<VgpuSchedulePolicy>;
        default: undefined;
    };
    quota: {
        type: import("vue").PropType<import("../types").GpuQuota>;
        default: () => {
            types: never[];
            resources: {};
        };
    };
    formWidth: {
        type: StringConstructor;
        default: undefined;
    };
    usedQuota: {
        type: import("vue").PropType<import("../types").GpuQuota>;
        default: undefined;
    };
    availableQuota: {
        type: import("vue").PropType<import("../types").GpuQuota>;
        default: undefined;
    };
    withPrefixRequest: {
        type: BooleanConstructor;
        default: boolean;
    };
    limit: {
        type: NumberConstructor;
        default: undefined;
    };
}>> & {
    onChange?: ((...args: any[]) => any) | undefined;
    "onUpdate:nvidiaVgpuModel"?: ((...args: any[]) => any) | undefined;
    "onUpdate:nvidiaVgpuPriority"?: ((...args: any[]) => any) | undefined;
    "onUpdate:nvidiaVgpuGpuSchedule"?: ((...args: any[]) => any) | undefined;
    "onUpdate:nvidiaVgpuNodeSchedule"?: ((...args: any[]) => any) | undefined;
    "onUpdate:nvidiaVgpuDevices"?: ((...args: any[]) => any) | undefined;
}, {
    limit: number;
    formWidth: string;
    nvidiaVgpuModel: string;
    nvidiaVgpuDevices: string[];
    nvidiaVgpuGpuSchedule: VgpuSchedulePolicy;
    nvidiaVgpuNodeSchedule: VgpuSchedulePolicy;
    gpuSettingsAdaptor: import("../props").GPUSettings;
    nvidiaVgpuModelsAdaptor: {
        data: import("../types").GPUSummary[];
        loading: boolean;
        refresh: () => import("../types").GPUSummary[] | Promise<import("../types").GPUSummary[]>;
    };
    nvidiaVgpuDevicesAdaptor: import("../props").GpuDevicesAdaptor;
    targetType: string;
    enableRemoteCall: boolean;
    enableRangeValidate: boolean;
    enableNvidiaVgpuModel: boolean;
    enableNvidiaVgpuDevices: boolean;
    enableNvidiaVgpuPriority: boolean;
    nvidiaVgpuPriority: "0" | "1";
    dynamicLimitOne: boolean;
    enableNvidiaVgpuSchedulePolicy: boolean;
    quota: import("../types").GpuQuota;
    usedQuota: import("../types").GpuQuota;
    availableQuota: import("../types").GpuQuota;
    withPrefixRequest: boolean;
}>;
export default _default;