import type { GpuQuotaItem } from '../types';
import type { GpuFormOptionsMap } from './gpuForm.internal-types';
export declare function useGpuFormState(): {
    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?: import("../types").VgpuSchedulePolicy | undefined;
        nvidiaVgpuNodeSchedule?: import("../types").VgpuSchedulePolicy | undefined;
    }[]>;
    rowsRef: import("vue").Ref<({
        $: import("vue").ComponentInternalInstance;
        $data: {};
        $props: Partial<{
            nvidiaVgpuModel: string;
            nvidiaVgpuDevices: string[];
            nvidiaVgpuGpuSchedule: import("../types").VgpuSchedulePolicy;
            nvidiaVgpuNodeSchedule: import("../types").VgpuSchedulePolicy;
            gpuSettingsAdaptor: import("..").GPUSettings;
            nvidiaVgpuModelsAdaptor: {
                data: import("../types").GPUSummary[];
                loading: boolean;
                refresh: () => import("../types").GPUSummary[] | Promise<import("../types").GPUSummary[]>;
            };
            nvidiaVgpuDevicesAdaptor: import("..").GpuDevicesAdaptor;
            targetType: string;
            gpuUsage: import("../types").GpuUsage;
            enableRemoteCall: boolean;
            enableRangeValidate: boolean;
            enableNvidiaVgpuModel: boolean;
            enableNvidiaVgpuDevices: boolean;
            assignGpuDisabled: boolean;
            enableNvidiaVgpuPriority: boolean;
            nvidiaVgpuPriority: "0" | "1";
            dynamicLimitOne: boolean;
            enableNvidiaVgpuSchedulePolicy: boolean;
            quotaItem: GpuQuotaItem;
            isSide: boolean;
            gpuProvider: string;
            availableQuotaItem: GpuQuotaItem;
            usedQuotaItem: GpuQuotaItem;
            existTypes: string[];
            nvidiaGpuDevices: import("..").GpuDevice[];
        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
            gpuSettingsAdaptor: {
                type: import("vue").PropType<import("..").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("..").GpuDevicesAdaptor>;
                default: undefined;
            };
            targetType: {
                type: StringConstructor;
                default: string;
            };
            gpuUsage: {
                type: import("vue").PropType<import("../types").GpuUsage>;
                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;
            };
            assignGpuDisabled: {
                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<import("../types").VgpuSchedulePolicy>;
                default: undefined;
            };
            nvidiaVgpuNodeSchedule: {
                type: import("vue").PropType<import("../types").VgpuSchedulePolicy>;
                default: undefined;
            };
            quotaItem: {
                type: import("vue").PropType<GpuQuotaItem>;
                default: () => {};
            };
            isSide: {
                type: BooleanConstructor;
                default: boolean;
            };
            gpuProvider: {
                type: StringConstructor;
                default: string;
            };
            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("..").GpuDevice[]>;
                default: () => never[];
            };
        }>> & {
            onChange?: ((...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" | "gpuUsage" | "enableRemoteCall" | "enableRangeValidate" | "enableNvidiaVgpuModel" | "enableNvidiaVgpuDevices" | "assignGpuDisabled" | "enableNvidiaVgpuPriority" | "nvidiaVgpuPriority" | "dynamicLimitOne" | "enableNvidiaVgpuSchedulePolicy" | "quotaItem" | "isSide" | "gpuProvider" | "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" | "refreshGpuOptionsMap", ...args: any[]) => void;
        $el: any;
        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
            gpuSettingsAdaptor: {
                type: import("vue").PropType<import("..").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("..").GpuDevicesAdaptor>;
                default: undefined;
            };
            targetType: {
                type: StringConstructor;
                default: string;
            };
            gpuUsage: {
                type: import("vue").PropType<import("../types").GpuUsage>;
                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;
            };
            assignGpuDisabled: {
                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<import("../types").VgpuSchedulePolicy>;
                default: undefined;
            };
            nvidiaVgpuNodeSchedule: {
                type: import("vue").PropType<import("../types").VgpuSchedulePolicy>;
                default: undefined;
            };
            quotaItem: {
                type: import("vue").PropType<GpuQuotaItem>;
                default: () => {};
            };
            isSide: {
                type: BooleanConstructor;
                default: boolean;
            };
            gpuProvider: {
                type: StringConstructor;
                default: string;
            };
            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("..").GpuDevice[]>;
                default: () => never[];
            };
        }>> & {
            onChange?: ((...args: any[]) => any) | undefined;
            onRefreshGpuOptionsMap?: ((...args: any[]) => any) | undefined;
        }, {
            nvidiaVgpuModelKey: string;
            nvidiaVgpuPriorityKey: string;
            yup: typeof import("yup");
            isNvidiaVgpu: (key?: string | undefined) => boolean;
            isNvidiaMig: (key?: string | undefined) => boolean;
            quota: GpuQuotaItem;
            dynamicQuota: import("vue").Ref<Record<string, string | number | undefined> | undefined>;
            currentDisplayResource: import("vue").ComputedRef<import("../types").GPUResourceSetting[] | undefined>;
            currentGpuProvider: import("vue").ComputedRef<string>;
            isShowHamiGpuHelper: import("vue").ComputedRef<boolean>;
            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;
            };
            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>;
            gpuAdvancedFormProps: import("vue").ComputedRef<{
                enableRemoteCall: boolean;
                enableNvidiaVgpuModel: boolean;
                enableNvidiaVgpuDevices: boolean;
                assignGpuDisabled: boolean;
                enableNvidiaVgpuPriority: boolean;
                enableNvidiaVgpuSchedulePolicy: boolean;
                nvidiaGpuModels: string[] | undefined;
                nvidiaVgpuModelsAdaptor: {
                    data: import("../types").GPUSummary[];
                    loading: boolean;
                    refresh: () => import("../types").GPUSummary[] | Promise<import("../types").GPUSummary[]>;
                } | undefined;
                nvidiaVgpuDevicesAdaptor: import("..").GpuDevicesAdaptor | undefined;
                isSide: boolean;
            }>;
            showDynamicForm: import("vue").ComputedRef<boolean | undefined>;
        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "refreshGpuOptionsMap")[], string, {
            nvidiaVgpuModel: string;
            nvidiaVgpuDevices: string[];
            nvidiaVgpuGpuSchedule: import("../types").VgpuSchedulePolicy;
            nvidiaVgpuNodeSchedule: import("../types").VgpuSchedulePolicy;
            gpuSettingsAdaptor: import("..").GPUSettings;
            nvidiaVgpuModelsAdaptor: {
                data: import("../types").GPUSummary[];
                loading: boolean;
                refresh: () => import("../types").GPUSummary[] | Promise<import("../types").GPUSummary[]>;
            };
            nvidiaVgpuDevicesAdaptor: import("..").GpuDevicesAdaptor;
            targetType: string;
            gpuUsage: import("../types").GpuUsage;
            enableRemoteCall: boolean;
            enableRangeValidate: boolean;
            enableNvidiaVgpuModel: boolean;
            enableNvidiaVgpuDevices: boolean;
            assignGpuDisabled: boolean;
            enableNvidiaVgpuPriority: boolean;
            nvidiaVgpuPriority: "0" | "1";
            dynamicLimitOne: boolean;
            enableNvidiaVgpuSchedulePolicy: boolean;
            quotaItem: GpuQuotaItem;
            isSide: boolean;
            gpuProvider: string;
            availableQuotaItem: GpuQuotaItem;
            usedQuotaItem: GpuQuotaItem;
            existTypes: string[];
            nvidiaGpuDevices: import("..").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("..").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("..").GpuDevicesAdaptor>;
            default: undefined;
        };
        targetType: {
            type: StringConstructor;
            default: string;
        };
        gpuUsage: {
            type: import("vue").PropType<import("../types").GpuUsage>;
            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;
        };
        assignGpuDisabled: {
            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<import("../types").VgpuSchedulePolicy>;
            default: undefined;
        };
        nvidiaVgpuNodeSchedule: {
            type: import("vue").PropType<import("../types").VgpuSchedulePolicy>;
            default: undefined;
        };
        quotaItem: {
            type: import("vue").PropType<GpuQuotaItem>;
            default: () => {};
        };
        isSide: {
            type: BooleanConstructor;
            default: boolean;
        };
        gpuProvider: {
            type: StringConstructor;
            default: string;
        };
        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("..").GpuDevice[]>;
            default: () => never[];
        };
    }>> & {
        onChange?: ((...args: any[]) => any) | undefined;
        onRefreshGpuOptionsMap?: ((...args: any[]) => any) | undefined;
    } & import("vue").ShallowUnwrapRef<{
        nvidiaVgpuModelKey: string;
        nvidiaVgpuPriorityKey: string;
        yup: typeof import("yup");
        isNvidiaVgpu: (key?: string | undefined) => boolean;
        isNvidiaMig: (key?: string | undefined) => boolean;
        quota: GpuQuotaItem;
        dynamicQuota: import("vue").Ref<Record<string, string | number | undefined> | undefined>;
        currentDisplayResource: import("vue").ComputedRef<import("../types").GPUResourceSetting[] | undefined>;
        currentGpuProvider: import("vue").ComputedRef<string>;
        isShowHamiGpuHelper: import("vue").ComputedRef<boolean>;
        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;
        };
        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>;
        gpuAdvancedFormProps: import("vue").ComputedRef<{
            enableRemoteCall: boolean;
            enableNvidiaVgpuModel: boolean;
            enableNvidiaVgpuDevices: boolean;
            assignGpuDisabled: boolean;
            enableNvidiaVgpuPriority: boolean;
            enableNvidiaVgpuSchedulePolicy: boolean;
            nvidiaGpuModels: string[] | undefined;
            nvidiaVgpuModelsAdaptor: {
                data: import("../types").GPUSummary[];
                loading: boolean;
                refresh: () => import("../types").GPUSummary[] | Promise<import("../types").GPUSummary[]>;
            } | undefined;
            nvidiaVgpuDevicesAdaptor: import("..").GpuDevicesAdaptor | undefined;
            isSide: boolean;
        }>;
        showDynamicForm: import("vue").ComputedRef<boolean | undefined>;
    }> & {} & import("vue").ComponentCustomProperties & {})[]>;
    existTypes: import("vue").ComputedRef<string[]>;
    updateRow: (idx: number, newRow: GpuQuotaItem) => void;
    addRow: () => void;
    removeRow: (idx: number) => void;
    filterRows: (optionsMap: GpuFormOptionsMap) => void;
    validate: () => Promise<{
        valid: boolean;
        message: string;
    }>;
};