import { Unit } from 'effector';
import * as solid_js_types_reactive_signal from 'solid-js/types/reactive/signal';
import { Component } from 'solid-js';

type Shape = {
    [key: string]: Unit<any>;
};
type UnprefixedKey<Original> = Original extends `$${infer Unprefixed}` ? Unprefixed : Original;
type PrefixedKey<Key extends string> = `$${Key}`;
type Unprefixed<T extends Shape> = {
    [key in UnprefixedKey<keyof T>]: T extends {
        [inner in key]: unknown;
    } ? T[key] : key extends string ? T[PrefixedKey<key>] : never;
};

type OnlyUnits<T> = Pick<T, {
    [Key in keyof T]-?: T[Key] extends Unit<unknown> ? Key : never;
}[keyof T]>;

/**
 * Creates model `factory`
 * @param creator Function that returns new `model` instance
 * @returns Factory with `createModel` method, `useModel` hook and model `Provider`
 */
declare const modelFactory: <T extends (...args: any[]) => any>(creator: T) => {
    /** Function that returns new `model` instance */
    createModel: T;
    /** Hook that returns current `model` instance */
    useModel: () => NonNullable<ReturnType<T>>;
    /** `Provider` to pass current `model` instance into */
    Provider: solid_js_types_reactive_signal.ContextProviderComponent<ReturnType<T> | null>;
    '@@unitShape': () => Unprefixed<OnlyUnits<NonNullable<ReturnType<T>>>>;
};
type Model<Factory extends ReturnType<typeof modelFactory>> = ReturnType<Factory['createModel']>;
/**
 * HOC that wraps your `View` into model `Provider`. Also adds `model` prop that will be passed into `Provider`
 * @param factory Factory that will be passed through Context
 * @param View Root component that will be wrapped into Context
 * @returns Wrapped component
 */
declare const modelView: <U extends {}, T extends {
    /** Function that returns new `model` instance */
    createModel: (...args: any[]) => any;
    /** Hook that returns current `model` instance */
    useModel: () => any;
    /** `Provider` to pass current `model` instance into */
    Provider: solid_js_types_reactive_signal.ContextProviderComponent<any>;
    '@@unitShape': () => Unprefixed<OnlyUnits<any>>;
}>(factory: T, View: Component<U & {
    model: ReturnType<T["createModel"]>;
}>) => Component<U & {
    model: ReturnType<T["createModel"]>;
}>;

export { Model, modelFactory, modelView };