import * as mobx_view_model from 'mobx-view-model';
import { AnyViewModel, AnyViewModelSimple, ViewModelCreateConfig, ViewModelsConfig, ViewModelSimple, ViewModelLookup, ViewModelStore, ViewModel } from 'mobx-view-model';
import * as react from 'react';
import { Maybe, Class, IsPartial, AnyObject, IsAny, IsUnknown, Defined, EmptyObject, HasKey } from 'yummies/types';

type RComponentState = react.ComponentState;
type RReactNode = react.ReactNode;
type RForwardedRef<T> = react.ForwardedRef<T>;
type RComponentType<P = {}> = react.ComponentType<P>;
type RLegacyRef<T> = react.LegacyRef<T>;
type RComponentClass<P = {}, S = RComponentState> = react.ComponentClass<P, S>;
/** Value accepted by React [`use()`](https://react.dev/reference/react/use). */
type RUsable<T> = react.Usable<T>;

/**
 * This is a provider for the `ActiveViewModelContext`.
 * This HOC is not recommended for public usage.
 * Better to use `withViewModel` HOC.
 */
declare const ActiveViewModelProvider: RComponentType<{
    value: AnyViewModel | AnyViewModelSimple;
    children?: RReactNode;
}>;

interface UseCreateViewModelConfig<TViewModel extends AnyViewModel> extends Pick<ViewModelCreateConfig<TViewModel>, 'vmConfig' | 'ctx' | 'component' | 'anchors' | 'props'> {
    /**
     * Unique identifier for the view
     *
     * [**Documentation**](https://js2me.github.io/mobx-view-model/react/api/with-view-model.html#id)
     */
    id?: Maybe<string>;
    /**
     * Function to generate an identifier for the view model
     *
     * [**Documentation**](https://js2me.github.io/mobx-view-model/react/api/with-view-model.html#generateid)
     */
    generateId?: ViewModelsConfig<TViewModel>['generateId'];
    /**
     * Function to create an instance of the VM class
     *
     * [**Documentation**](https://js2me.github.io/mobx-view-model/react/api/with-view-model.html#factory)
     */
    factory?: ViewModelsConfig<TViewModel>['factory'];
}
/**
 * Creates new instance of ViewModel
 *
 * [**Documentation**](https://js2me.github.io/mobx-view-model/react/api/use-create-view-model.html)
 */
declare function useCreateViewModel<TViewModel extends AnyViewModel>(VM: Class<TViewModel>, ...args: IsPartial<TViewModel['payload']> extends true ? [
    payload?: TViewModel['payload'],
    config?: UseCreateViewModelConfig<TViewModel>
] : [
    payload: TViewModel['payload'],
    config?: UseCreateViewModelConfig<TViewModel>
]): TViewModel;
/**
 * Creates new instance of ViewModelSimple
 *
 * [**Documentation**](https://js2me.github.io/mobx-view-model/react/api/use-create-view-model.html)
 */
declare function useCreateViewModel<TPayload extends AnyObject, TViewModelSimple extends ViewModelSimple<TPayload>>(VM: Class<TViewModelSimple>, ...args: IsPartial<TPayload> extends true ? [payload?: TPayload] : [payload: TPayload]): TViewModelSimple;
/**
 * Creates new instance of ViewModelSimple
 *
 * [**Documentation**](https://js2me.github.io/mobx-view-model/react/api/use-create-view-model.html)
 */
declare function useCreateViewModel<TViewModelSimple>(VM: Class<TViewModelSimple>): TViewModelSimple;

/**
 * Get access to **already created** instance of ViewModel
 *
 * [**Documentation**](https://js2me.github.io/mobx-view-model/react/api/use-view-model.html)
 */
declare const useViewModel: <T extends AnyViewModel | AnyViewModelSimple>(vmLookup?: ViewModelLookup<T>) => T;

type OnlyViewModelProps<TViewModel extends AnyViewModel> = {
    model: Class<TViewModel>;
    children?: RReactNode | ((model: TViewModel) => RReactNode);
} & (IsPartial<TViewModel['payload']> extends true ? {
    payload?: TViewModel['payload'];
    config?: UseCreateViewModelConfig<TViewModel>;
} : {
    payload: TViewModel['payload'];
    config?: UseCreateViewModelConfig<TViewModel>;
});
declare const OnlyViewModel: (<TViewModel extends AnyViewModel>({ model, config, payload, children, }: OnlyViewModelProps<TViewModel>) => string | number | bigint | boolean | Iterable<react.ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<react.ReactNode> | null | undefined> | react.JSX.Element | null | undefined) & {
    displayName: string;
};

declare const ViewModelsProvider: RComponentType<{
    value: ViewModelStore;
    children?: RReactNode;
}>;

declare const ActiveViewModelContext: react.Context<AnyViewModel | AnyViewModelSimple>;

/**
 * Context which contains the view models store instance.
 * This context is used to access the view models store inside the React components.
 * @see {@link ViewModelStore}
 */
declare const ViewModelsContext: react.Context<ViewModelStore<mobx_view_model.AnyViewModel>>;

type FixedComponentType<P extends AnyObject = {}> = 
/**
 * Fixes typings loss with use `withViewModel` with inline function component
 */
((props: P) => RReactNode) | RComponentClass<P>;
type ExtractReactRef<T> = Defined<T> extends RForwardedRef<infer TForwardedRef> ? TForwardedRef : Defined<T> extends RLegacyRef<infer TRef> ? TRef : T;
/**
 * This type is needed to declare prop types for your View component wrapped into `withViewModel` HOC
 *
 * Use second generic type add typings for `forwardedRef` prop
 */
type ViewModelProps<VM, TForwardedRef = unknown> = IsAny<TForwardedRef> extends true ? {
    model: VM;
    forwardedRef?: RForwardedRef<TForwardedRef>;
} : IsUnknown<TForwardedRef> extends true ? {
    model: VM;
} : {
    model: VM;
    forwardedRef?: RForwardedRef<TForwardedRef>;
};
type ViewModelPropsChargedProps<TComponentOriginProps extends AnyObject, TViewModel, TForwardedRef = unknown> = HasKey<TComponentOriginProps, 'ref'> extends true ? Omit<TComponentOriginProps, 'ref'> & ViewModelProps<TViewModel, ExtractReactRef<TComponentOriginProps['ref']>> : HasKey<TComponentOriginProps, 'forwardedRef'> extends true ? TComponentOriginProps : TComponentOriginProps & ViewModelProps<TViewModel, IsUnknown<TForwardedRef> extends true ? any : TForwardedRef>;
type VMInputPayloadPropObj<VM> = VM extends ViewModel<infer TPayload, any> ? TPayload extends EmptyObject ? {} : IsPartial<TPayload> extends true ? {
    payload?: TPayload;
} : {
    payload: TPayload;
} : VM extends ViewModelSimple<infer TPayload> ? TPayload extends EmptyObject ? {} : IsPartial<TPayload> extends true ? {
    payload?: TPayload;
} : {
    payload: TPayload;
} : {};
type WithViewModelReactHook = (allProps: AnyObject, ctx: AnyObject, viewModels: Maybe<ViewModelStore>, ref?: any) => void;
interface ViewModelHocConfig<VM extends AnyViewModel> extends Omit<UseCreateViewModelConfig<VM>, 'component' | 'componentProps'> {
    /**
     * Component to render if the view model initialization takes too long
     *
     * [**Documentation**](https://js2me.github.io/mobx-view-model/react/api/with-view-model.html#fallback)
     */
    fallback?: RComponentType;
    /**
     * Function to invoke additional React hooks in the resulting component
     *
     * [**Documentation**](https://js2me.github.io/mobx-view-model/react/api/with-view-model.html#reacthook)
     */
    reactHook?: WithViewModelReactHook;
    /**
     * Function that should return the payload for the VM
     * by default, it is - (props) => props.payload
     *
     * [**Documentation**](https://js2me.github.io/mobx-view-model/react/api/with-view-model.html#getpayload)
     */
    getPayload?: (allProps: any) => any;
    /**
     * Forwards ref using `RforwardRef` but pass it to props as prop `ref`
     *
     * [**Documentation**](https://js2me.github.io/mobx-view-model/react/api/with-view-model.html#forwardref)
     */
    forwardRef?: boolean;
    /**
     * Additional component anchors for the same VM instance.
     * useViewModel(AnchorComponent) will return this VM when the connected component is mounted.
     */
    anchors?: RComponentType[];
}
interface ViewModelSimpleHocConfig<_VM> {
    /**
     * Component to render if the view model initialization takes too long
     *
     * [**Documentation**](https://js2me.github.io/mobx-view-model/react/api/with-view-model.html#fallback)
     */
    fallback?: RComponentType;
    /**
     * Function to invoke additional React hooks in the resulting component
     *
     * [**Documentation**](https://js2me.github.io/mobx-view-model/react/api/with-view-model.html#reacthook)
     */
    reactHook?: WithViewModelReactHook;
    /**
     * Function that should return the payload for the VM
     * by default, it is - (props) => props.payload
     *
     * [**Documentation**](https://js2me.github.io/mobx-view-model/react/api/with-view-model.html#getpayload)
     */
    getPayload?: (allProps: any) => any;
    /**
     * Forwards ref using `RforwardRef` but pass it to props as prop `ref`
     *
     * [**Documentation**](https://js2me.github.io/mobx-view-model/react/api/with-view-model.html#forwardref)
     */
    forwardRef?: boolean;
    /**
     * Additional component anchors for the same VM instance.
     * useViewModel(AnchorComponent) will return this VM when the connected component is mounted.
     */
    anchors?: RComponentType[];
}
type AllViewModelPropsKeys = keyof Required<ViewModelProps<any, any>>;
type VMComponentProps<TViewModel, TComponentOriginProps extends AnyObject = AnyObject, TForwardedRef = unknown> = Omit<TComponentOriginProps, AllViewModelPropsKeys> & VMInputPayloadPropObj<TViewModel> & (HasKey<TComponentOriginProps, 'ref'> extends true ? {} : HasKey<TComponentOriginProps, 'forwardedRef'> extends true ? Required<TComponentOriginProps>['forwardedRef'] extends RLegacyRef<any> ? {
    ref?: TComponentOriginProps['forwardedRef'];
} : Pick<TComponentOriginProps, 'forwardedRef'> : IsUnknown<TForwardedRef> extends true ? {} : {
    ref?: RLegacyRef<TForwardedRef>;
});
interface VMComponent<TViewModel, TComponentOriginProps extends AnyObject = AnyObject, TForwardedRef = unknown> {
    (props: VMComponentProps<TViewModel, TComponentOriginProps, TForwardedRef>): RReactNode;
    /**
     * Registers an anchor component for the same VM instance.
     * `useViewModel(anchor)` will return this VM when the connected component is mounted.
     * Anchors are stored in config.anchors and passed to the store's link() during processCreateConfig.
     * @param anchor - React component to use as lookup key for useViewModel
     */
    connect(anchor: RComponentType<any>): VMComponent<TViewModel, TComponentOriginProps, TForwardedRef>;
}
/**
 * A Higher-Order Component that connects React components to their ViewModels, providing seamless MobX integration.
 *
 * [**Documentation**](https://js2me.github.io/mobx-view-model/react/api/with-view-model.html)
 */
declare function withViewModel<TViewModel extends AnyViewModel, TComponentOriginProps extends AnyObject = AnyObject, TForwardedRef = unknown>(model: Class<TViewModel>, component: RComponentType<ViewModelPropsChargedProps<TComponentOriginProps, TViewModel, TForwardedRef>>, config?: ViewModelHocConfig<TViewModel>): VMComponent<TViewModel, TComponentOriginProps, TForwardedRef>;
/**
 * A Higher-Order Component that connects React components to their ViewModels, providing seamless MobX integration.
 *
 * [**Documentation**](https://js2me.github.io/mobx-view-model/react/api/with-view-model.html)
 */
declare function withViewModel<TViewModel extends AnyViewModel, TForwardedRef = unknown>(model: Class<TViewModel>, config?: ViewModelHocConfig<TViewModel>): <TComponentOriginProps extends AnyObject = ViewModelProps<TViewModel>>(Component?: RComponentType<ViewModelPropsChargedProps<TComponentOriginProps, TViewModel, TForwardedRef>>) => VMComponent<TViewModel, TComponentOriginProps, TForwardedRef>;
/**
 * A Higher-Order Component that connects React components to their ViewModels, providing seamless MobX integration.
 *
 * [**Documentation**](https://js2me.github.io/mobx-view-model/react/api/with-view-model.html)
 */
declare function withViewModel<TViewModel, TForwardedRef = unknown>(model: Class<TViewModel>, config?: ViewModelSimpleHocConfig<TViewModel>): <TComponentOriginProps extends AnyObject = ViewModelProps<TViewModel>>(Component?: FixedComponentType<ViewModelPropsChargedProps<TComponentOriginProps, TViewModel, TForwardedRef>>) => VMComponent<TViewModel, TComponentOriginProps, TForwardedRef>;
/**
 * A Higher-Order Component that connects React components to their ViewModels, providing seamless MobX integration.
 *
 * [**Documentation**](https://js2me.github.io/mobx-view-model/react/api/with-view-model.html)
 */
declare function withViewModel<TViewModel extends AnyViewModelSimple, TComponentOriginProps extends AnyObject = AnyObject, TForwardedRef = unknown>(model: Class<TViewModel>, component: FixedComponentType<ViewModelPropsChargedProps<TComponentOriginProps, TViewModel, TForwardedRef>>, config?: ViewModelSimpleHocConfig<TViewModel>): VMComponent<TViewModel, TComponentOriginProps, TForwardedRef>;
/**
 * A Higher-Order Component that connects React components to their ViewModels, providing seamless MobX integration.
 *
 * [**Documentation**](https://js2me.github.io/mobx-view-model/react/api/with-view-model.html)
 */
declare function withViewModel<TViewModel, TComponentOriginProps extends AnyObject = ViewModelProps<TViewModel>, TForwardedRef = unknown>(model: Class<TViewModel>, component: FixedComponentType<ViewModelPropsChargedProps<TComponentOriginProps, TViewModel, TForwardedRef>>, config?: ViewModelSimpleHocConfig<TViewModel>): VMComponent<TViewModel, TComponentOriginProps, TForwardedRef>;

type InferPropsViewModelPayload<TViewModel> = TViewModel extends AnyViewModel ? TViewModel['payload'] : TViewModel extends {
    setPayload(payload: infer TPayload extends AnyObject): any;
} ? TPayload : TViewModel extends ViewModelSimple<infer TPayload extends AnyObject> ? TPayload : EmptyObject;
type ExtractVMPayload<VM> = InferPropsViewModelPayload<VM>;
type PropsVMComponentProps<TViewModel, TComponentOriginProps extends AnyObject = ExtractVMPayload<TViewModel>, TForwardedRef = unknown> = ExtractVMPayload<TViewModel> & Omit<TComponentOriginProps, AllViewModelPropsKeys | keyof ExtractVMPayload<TViewModel>> & (HasKey<TComponentOriginProps, 'ref'> extends true ? {} : HasKey<TComponentOriginProps, 'forwardedRef'> extends true ? Required<TComponentOriginProps>['forwardedRef'] extends RForwardedRef<infer R> ? {
    ref?: RLegacyRef<R>;
} : Required<TComponentOriginProps>['forwardedRef'] extends RLegacyRef<any> ? {
    ref?: TComponentOriginProps['forwardedRef'];
} : Pick<TComponentOriginProps, 'forwardedRef'> : IsUnknown<TForwardedRef> extends true ? {} : {
    ref?: RLegacyRef<TForwardedRef>;
});
interface PropsVMComponent<TViewModel, TComponentOriginProps extends AnyObject = ExtractVMPayload<TViewModel>, TForwardedRef = unknown> {
    (props: PropsVMComponentProps<TViewModel, TComponentOriginProps, TForwardedRef>): RReactNode;
    connect(anchor: RComponentType<any>): PropsVMComponent<TViewModel, TComponentOriginProps, TForwardedRef>;
}
type PropsViewModelHocConfig<VM extends AnyViewModel> = Omit<ViewModelHocConfig<VM>, 'getPayload'>;
type PropsViewModelSimpleHocConfig<VM> = Omit<ViewModelSimpleHocConfig<VM>, 'getPayload'>;
/**
 * Like `withViewModel`, but treats all component props as the ViewModel payload.
 * The resulting component does not require a separate `payload` prop.
 *
 * [**Documentation**](https://js2me.github.io/mobx-view-model/react/api/with-props-view-model.html)
 */
declare function withPropsViewModel<TViewModel, TComponentOriginProps extends AnyObject = InferPropsViewModelPayload<TViewModel>, TForwardedRef = unknown>(model: Class<TViewModel>, component: FixedComponentType<ViewModelPropsChargedProps<TComponentOriginProps, TViewModel, TForwardedRef>>, config?: TViewModel extends AnyViewModel ? PropsViewModelHocConfig<TViewModel> : PropsViewModelSimpleHocConfig<TViewModel>): PropsVMComponent<TViewModel, TComponentOriginProps, TForwardedRef>;

export { ActiveViewModelContext, ActiveViewModelProvider, OnlyViewModel, ViewModelsContext, ViewModelsProvider, useCreateViewModel, useViewModel, withPropsViewModel, withViewModel };
export type { AllViewModelPropsKeys, ExtractReactRef, FixedComponentType, OnlyViewModelProps, PropsVMComponent, PropsVMComponentProps, PropsViewModelHocConfig, PropsViewModelSimpleHocConfig, RComponentClass, RComponentState, RComponentType, RForwardedRef, RLegacyRef, RReactNode, RUsable, UseCreateViewModelConfig, VMComponent, VMComponentProps, ViewModelHocConfig, ViewModelProps, ViewModelPropsChargedProps, ViewModelSimpleHocConfig, WithViewModelReactHook };