import { Observable, ObservableInput } from 'rxjs';
import { DomainConceptName } from './type';
export type SerializablePrimitives = void | undefined | number | string | boolean | null;
export type ReadonlySerializableArray = readonly Serializable[];
export type SerializableArray = Serializable[] | ReadonlySerializableArray;
export type SerializableObject = {
    [key: string]: Serializable;
};
export type Serializable = SerializablePrimitives | SerializableArray | SerializableObject;
export type ToType<T> = T extends object | unknown[] ? {
    [key in keyof T]: ToType<T[key]>;
} : T;
export type Args<T = unknown> = [] | [arg: T] | [arg?: T];
export type RemeshInjectedContext = {
    get<T extends Args<Serializable>, U>(input: RemeshQueryAction<T, U>): U;
    get<state>(input: RemeshStateItem<state>): state;
    get(input: RemeshStateItem<any> | RemeshQueryAction<any, any>): unknown;
    fromEvent: <T extends Args, U>(Event: RemeshEvent<T, U> | RemeshSubscribeOnlyEvent<T, U>) => Observable<U>;
    fromQuery: <T extends Args<Serializable>, U>(Query: RemeshQueryAction<T, U>) => Observable<U>;
};
export type RemeshEventContext = {
    get: RemeshInjectedContext['get'];
};
export type RemeshEvent<T extends Args, U> = {
    type: 'RemeshEvent';
    eventId: number;
    eventName: DomainConceptName<'Event'>;
    impl?: (context: RemeshEventContext, arg: T[0]) => U;
    (...args: T): RemeshEventAction<T, U>;
    emitted: (task: RemeshCommandTask<T>) => void;
    owner: RemeshDomainAction<any, any>;
    inspectable: boolean;
    toSubscribeOnlyEvent: () => RemeshSubscribeOnlyEvent<T, U>;
};
export type RemeshEventAction<T extends Args, U> = {
    type: 'RemeshEventAction';
    arg: T[0];
    Event: RemeshEvent<T, U>;
};
export type RemeshEventOptions<T extends Args, U> = {
    name: DomainConceptName<'Event'>;
    inspectable?: boolean;
    impl: (context: RemeshEventContext, ...args: T) => U;
};
export declare function RemeshEvent<T extends Args = [], U = void>(options: RemeshEventOptions<T, U>): RemeshEvent<T, U>;
export declare function RemeshEvent<T = void>(options: Omit<RemeshEventOptions<[T], T>, 'impl'>): RemeshEvent<[T], T>;
export type RemeshSubscribeOnlyEvent<_T, _U> = {
    type: 'RemeshSubscribeOnlyEvent';
    eventId: number;
    eventName: DomainConceptName<'Event'>;
};
export type ToRemeshSubscribeOnlyEvent<T> = T extends RemeshSubscribeOnlyEvent<any, any> ? T : T extends RemeshEvent<infer TT, infer UU> ? RemeshSubscribeOnlyEvent<TT, UU> : never;
export type ToRemeshSubscribeOnlyEventMap<T extends RemeshDomainOutput['event']> = {
    [K in keyof T]: ToRemeshSubscribeOnlyEvent<T[K]>;
};
export declare const toRemeshSubscribeOnlyEvent: <T, U>(event: RemeshEvent<any, U>) => RemeshSubscribeOnlyEvent<T, U>;
export declare const internalToOriginalEvent: <T extends Args<unknown>, U>(subscribeOnlyEvent: RemeshSubscribeOnlyEvent<T, U>) => RemeshEvent<T, U>;
export type CompareFn<T> = (prev: T, curr: T) => boolean;
export declare const DefaultStateValue: unique symbol;
export type DefaultStateValue = typeof DefaultStateValue;
export type RemeshState<T> = {
    type: 'RemeshState';
    stateId: number;
    stateName: DomainConceptName<'State'>;
    (): RemeshStateItem<T>;
    default: T | (() => T) | DefaultStateValue;
    owner: RemeshDomainAction<any, any>;
    compare: CompareFn<T>;
    inspectable: boolean;
};
export type RemeshStateItem<T> = {
    type: 'RemeshStateItem';
    State: RemeshState<T>;
    new: (state: T) => RemeshStateItemUpdatePayload<T>;
};
export type RemeshStateItemUpdatePayload<T> = {
    type: 'RemeshStateItemUpdatePayload';
    key?: string;
    value: T;
    stateItem: RemeshStateItem<T>;
};
export type RemeshStateOptions<T> = {
    name: DomainConceptName<'State'>;
    inspectable?: boolean;
    compare?: CompareFn<T>;
} & ({
    default: T | (() => T);
} | {
    defer: true;
});
export declare const defaultCompare: <T>(prev: T, curr: T) => boolean;
export declare const RemeshState: <T>(options: RemeshStateOptions<T>) => RemeshState<T>;
export type RemeshQueryContext = {
    get: RemeshInjectedContext['get'];
};
export type RemeshQuery<T extends Args<Serializable>, U> = {
    type: 'RemeshQuery';
    queryId: number;
    queryName: DomainConceptName<'Query'>;
    impl: (context: RemeshQueryContext, arg: T[0]) => U;
    (...args: T): RemeshQueryAction<T, U>;
    owner: RemeshDomainAction<any, any>;
    onError?: (error: Error, value: U) => U;
    compare: CompareFn<U>;
    changed: (task: RemeshCommandTask<[{
        current: U;
        previous: U;
    }]>) => void;
    inspectable: boolean;
};
export type RemeshQueryAction<T extends Args<Serializable>, U> = {
    type: 'RemeshQueryAction';
    Query: RemeshQuery<T, U>;
    arg: T[0];
};
export type RemeshQueryOptions<T extends Args<Serializable>, U> = {
    name: DomainConceptName<'Query'>;
    inspectable?: boolean;
    impl: (context: RemeshQueryContext, ...args: T) => U;
    onError?: (error: Error, previous: U) => U;
    compare?: RemeshQuery<T, U>['compare'];
};
export declare const RemeshQuery: <T extends Args<Serializable>, U>(options: RemeshQueryOptions<T, U>) => RemeshQuery<T, U>;
export type RemeshCommandContext = {
    get: RemeshInjectedContext['get'];
};
export type RemeshCommandAction<T extends Args> = {
    type: 'RemeshCommandAction';
    arg: T[0];
    Command: RemeshCommand<T>;
};
export type RemeshCommandOutput = RemeshCommandAction<any> | RemeshEventAction<any, any> | RemeshStateItemUpdatePayload<any> | RemeshCommandOutput[] | null;
export type RemeshCommand<T extends Args> = {
    type: 'RemeshCommand';
    commandId: number;
    commandName: DomainConceptName<'Command'>;
    impl: (context: RemeshCommandContext, arg: T[0]) => RemeshCommandOutput;
    (...args: T): RemeshCommandAction<T>;
    owner: RemeshDomainAction<any, any>;
    before: (task: RemeshCommandTask<T>) => void;
    after: (task: RemeshCommandTask<T>) => void;
    inspectable: boolean;
};
type RemeshCommandTask<T extends Args> = (context: RemeshCommandContext, ...args: T) => RemeshCommandOutput;
export type RemeshCommandOptions<T extends Args> = {
    name: DomainConceptName<'Command'>;
    inspectable?: boolean;
    impl: (context: RemeshCommandContext, ...args: T) => RemeshCommandOutput;
};
declare const remeshCommandTaskStore: {
    before: WeakMap<RemeshCommand<any>, Set<RemeshCommandTask<any>>>;
    after: WeakMap<RemeshCommand<any>, Set<RemeshCommandTask<any>>>;
    changed: WeakMap<RemeshQuery<any, any>, Set<RemeshCommandTask<any>>>;
    emitted: WeakMap<RemeshEvent<any, any>, Set<RemeshCommandTask<any>>>;
};
export declare const getCommandTaskSet: (key: unknown, type: keyof typeof remeshCommandTaskStore) => Set<RemeshCommandTask<any>> | undefined;
export declare const RemeshCommand: <T extends Args<unknown> = []>(options: RemeshCommandOptions<T>) => RemeshCommand<T>;
export type RemeshExternImpl<T> = {
    type: 'RemeshExternImpl';
    Extern: RemeshExtern<T>;
    value: T;
};
export type RemeshExtern<T> = {
    type: 'RemeshExtern';
    externId: number;
    default: T;
    impl(value: T): RemeshExternImpl<T>;
};
export type RemeshExternOptions<T> = {
    default: RemeshExtern<T>['default'];
};
export declare const RemeshExtern: <T>(options: RemeshExternOptions<T>) => RemeshExtern<T>;
export type RemeshDomainPreloadQueryContext = {
    get: RemeshInjectedContext['get'];
};
export type RemeshDomainPreloadCommandContext = {
    get: RemeshInjectedContext['get'];
};
export type RemeshDomainPreloadCommandOutput = RemeshStateItemUpdatePayload<any> | RemeshDomainPreloadCommandOutput[] | null;
export type RemeshDomainPreloadOptions<T extends Serializable> = {
    key: string;
    query: (context: RemeshDomainPreloadQueryContext) => Promise<T>;
    command: (context: RemeshDomainPreloadCommandContext, data: T) => RemeshDomainPreloadCommandOutput;
};
export type RemeshEffectContext = {
    get: RemeshInjectedContext['get'];
    fromEvent: RemeshInjectedContext['fromEvent'];
    fromQuery: RemeshInjectedContext['fromQuery'];
};
export type RemeshAction = RemeshEventAction<any, any> | RemeshCommandAction<any> | null | RemeshAction[];
export type RemeshEffect = {
    name: DomainConceptName<'Effect'>;
    impl: (context: RemeshEffectContext) => ObservableInput<RemeshAction> | null;
};
export type RemeshDomainContext = {
    state: typeof RemeshState;
    event: typeof RemeshEvent;
    query: typeof RemeshQuery;
    command: typeof RemeshCommand;
    effect: (effect: RemeshEffect) => void;
    preload: <T extends Serializable>(options: RemeshDomainPreloadOptions<T>) => void;
    getExtern: <T>(Extern: RemeshExtern<T>) => T;
    getDomain: <T extends RemeshDomainDefinition, U extends Args<Serializable>>(domainAction: RemeshDomainAction<T, U>) => {
        [key in keyof VerifiedRemeshDomainDefinition<T>]: VerifiedRemeshDomainDefinition<T>[key];
    };
    forgetDomain: <T extends RemeshDomainDefinition, U extends Args<Serializable>>(domainAction: RemeshDomainAction<T, U>) => void;
};
export type DomainTypeOf<T extends RemeshDomain<RemeshDomainDefinition, any>> = T extends RemeshDomain<infer Definition, any> ? VerifiedRemeshDomainDefinition<Definition> : never;
export type RemeshEvents = {
    [key: string]: RemeshEvent<any, any> | RemeshSubscribeOnlyEvent<any, any>;
};
export type RemeshQueries = {
    [key: string]: RemeshQuery<any, any>;
};
export type RemeshCommands = {
    [key: string]: RemeshCommand<any>;
};
export type RemeshDomainOutput = {
    event: RemeshEvents;
    query: RemeshQueries;
    command: RemeshCommands;
};
export type RemeshDomainDefinition = Partial<RemeshDomainOutput>;
export type VerifiedRemeshDomainDefinition<T extends RemeshDomainDefinition> = Pick<{
    event: {
        [key in keyof T['event']]: key extends DomainConceptName<'Event'> ? ToRemeshSubscribeOnlyEvent<T['event'][key]> : `${key & string} is not a valid event name`;
    };
    query: {
        [key in keyof T['query']]: key extends DomainConceptName<'Query'> ? T['query'][key] : `${key & string} is not a valid query name`;
    };
    command: {
        [key in keyof T['command']]: key extends DomainConceptName<'Command'> ? T['command'][key] : `${key & string} is not a valid command name`;
    };
}, ('event' | 'query' | 'command') & keyof T>;
export declare const toValidRemeshDomainDefinition: <T extends Partial<RemeshDomainOutput>>(domainDefinition: T) => VerifiedRemeshDomainDefinition<T>;
export declare const RemeshModule: <T extends Partial<RemeshDomainOutput>>(module: T) => VerifiedRemeshDomainDefinition<T> extends infer T_1 ? { [key in keyof T_1]: VerifiedRemeshDomainDefinition<T>[key]; } : never;
export type RemeshDomain<T extends RemeshDomainDefinition, U extends Args<Serializable>> = {
    type: 'RemeshDomain';
    domainName: DomainConceptName<'Domain'>;
    domainId: number;
    impl: (context: RemeshDomainContext, arg: U[0]) => T;
    (...args: U): RemeshDomainAction<T, U>;
    inspectable: boolean;
};
export type RemeshDomainAction<T extends RemeshDomainDefinition, U extends Args<Serializable>> = {
    type: 'RemeshDomainAction';
    Domain: RemeshDomain<T, U>;
    arg: U[0];
};
export type RemeshDomainOptions<T extends RemeshDomainDefinition, U extends Args<Serializable>> = {
    name: DomainConceptName<'Domain'>;
    inspectable?: boolean;
    impl: (context: RemeshDomainContext, ...args: U) => T;
};
export declare const RemeshDomain: <T extends Partial<RemeshDomainOutput>, U extends Args<Serializable>>(options: RemeshDomainOptions<T, U>) => RemeshDomain<T, U>;
export declare const DefaultDomain: RemeshDomain<{}, []>;
export {};