import { ActionFromReducer } from '@reduxjs/toolkit';
import { BoxProps } from '@mui/material';
import { createAction } from '@reduxjs/toolkit';
import { createAsyncThunk } from '@reduxjs/toolkit';
import { createSlice } from '@reduxjs/toolkit';
import { default as default_2 } from 'react';
import { Dispatch } from 'redux';
import { DrawerProps } from '@mui/material';
import { EnhancedStore } from '@reduxjs/toolkit';
import { FC } from 'react';
import { IconButtonProps } from '@mui/material';
import { JSX as JSX_2 } from 'react/jsx-runtime';
import { PreloadedStateShapeFromReducersMapObject } from 'redux';
import { Reducer } from '@reduxjs/toolkit';
import { ReducerFromReducersMapObject } from '@reduxjs/toolkit';
import { StateFromReducersMapObject } from '@reduxjs/toolkit';
import { StoreEnhancer } from 'redux';
import { ThemeOptions } from '@material-ui/core/styles';
import { ThunkDispatch } from 'redux-thunk';
import { ToolbarProps } from '@mui/material';
import { Tuple } from '@reduxjs/toolkit';
import { UnknownAction } from 'redux';

export declare const AppWithToolbarDrawer: FC<AppWithToolbarDrawerConfig>;

export declare interface AppWithToolbarDrawerConfig {
    themeOptions?: ThemeOptions;
    toolbar?: AppWithToolbarDrawerConfigToolbar;
    drawer?: AppWithToolbarDrawerConfigDrawer;
    children?: default_2.JSX.Element;
}

export declare interface AppWithToolbarDrawerConfigDrawer {
    options?: DrawerProps;
    container?: BoxProps;
    layout?: AppWithToolbarDrawerConfigLayoutDrawer;
}

export declare interface AppWithToolbarDrawerConfigLayoutDrawer {
    Menu?: default_2.JSX.Element;
}

export declare interface AppWithToolbarDrawerConfigLayoutToolbar {
    Toolbar?: default_2.JSX.Element;
}

export declare interface AppWithToolbarDrawerConfigToolbar {
    options?: ToolbarProps;
    iconButton?: IconButtonProps;
    icon?: default_2.JSX.Element;
    layout?: AppWithToolbarDrawerConfigLayoutToolbar;
}

export { createAction }

export { createAsyncThunk }

export { createSlice }

declare const _default: {
    useDispatch: typeof useDispatch;
    useSelector: typeof useSelector;
};

declare namespace DKA {
    export {
        Widget,
        Template,
        Redux,
        Hook
    }
}
export { DKA }

export declare const GeoAdministrative: FC<GeoAdministrativeSelectionProps>;

export declare type GeoAdministrativeConfig = GeoAdministrativeConfigURL | GeoAdministrativeConfigLocal | GeoAdministrativeConfigFirestore | GeoAdministrativeConfigDatabase;

export declare interface GeoAdministrativeConfigDatabase {
    type: GeoAdministrativeType.FIREBASE_DATABASE;
    credential: any;
}

export declare interface GeoAdministrativeConfigFirestore {
    type: GeoAdministrativeType.FIREBASE_FIRESTORE;
}

export declare interface GeoAdministrativeConfigLocal {
    type: GeoAdministrativeType.LOCAL;
    province?: Array<{
        id: string;
        name: string;
    }>;
    regency?: Array<{
        id: string;
        province_id: string;
        name: string;
    }>;
    district?: Array<{
        id: string;
        regency_id: string;
        name: string;
    }>;
    village?: Array<{
        id: string;
        district_id: string;
        name: string;
    }>;
}

export declare interface GeoAdministrativeConfigURL {
    type: GeoAdministrativeType.URL;
    host?: `${Protocol}${string}`;
    endpoint?: GeoAdministrativeConfigURLEndpoint;
}

export declare interface GeoAdministrativeConfigURLEndpoint {
    province?: `/${string}`;
    regency?: `/${string}`;
    district?: `/${string}`;
    village?: `/${string}`;
}

export declare interface GeoAdministrativeModels {
    province?: never;
    regency?: unknown;
    district?: unknown;
    village?: unknown;
}

export declare interface GeoAdministrativeSelectionProps {
    defaultValue?: GeoAdministrativeModels;
    config?: GeoAdministrativeConfig;
    onChange?: (data: GeoAdministrativeModels) => void;
}

export declare enum GeoAdministrativeType {
    URL = 0,
    LOCAL = 1,
    FIREBASE_FIRESTORE = 2,
    FIREBASE_DATABASE = 3
}

declare namespace Hook {
    export {
        useDispatch,
        useSelector,
        _default as default
    }
}

export declare type onChangeEventAutoCompleteTypes = (event?: default_2.SyntheticEvent, value: any, reason: string, details?: string | unknown) => void;

export declare type Protocol = "http://" | "https://";

export declare function Provider<T extends ProviderProps>(props: T): JSX_2.Element;

declare interface ProviderProps {
    reducers: ProviderReducer;
    children: default_2.JSX.Element;
}

declare type ProviderReducer = Reducer;

export declare function Reducers<T>(listReducers: T): T[keyof T] extends Reducer<any, any, any> | undefined ? Reducer<StateFromReducersMapObject<T>, ActionFromReducer<ReducerFromReducersMapObject<T>>, Partial<PreloadedStateShapeFromReducersMapObject<T>>> : never;

declare namespace Redux {
    export {
        Store,
        _default as Hook,
        Reducers,
        Provider
    }
}
export { Redux }

export declare const StepperLayout: FC<StepperLayoutConfig>;

export declare interface StepperLayoutConfig {
    item: StepperLayoutItem;
    onFinish?: () => void;
}

export declare type StepperLayoutItem = Array<StepperLayoutItemModel>;

export declare interface StepperLayoutItemModel {
    title: string;
    icon: default_2.ReactElement;
    children: default_2.JSX.Element;
    onBack?: () => void;
    onNext?: () => void;
}

declare function Store<T extends Reducer>(reducer: T): EnhancedStore<any, UnknownAction, Tuple<[StoreEnhancer<    {
dispatch: ThunkDispatch<any, undefined, UnknownAction>;
}>, StoreEnhancer]>>;

declare namespace Template {
    export {
        AppWithToolbarDrawer,
        StepperLayout
    }
}

export declare function useDispatch(): Dispatch<UnknownAction>;

export declare function useSelector<T>(selector: (state: T) => any): any;

declare namespace Widget {
    export {
        GeoAdministrative
    }
}
export { Widget }

export { }
