import { SessionID } from "cojson";
import { CoValueLoadingState, ItemsSym, TypeSym } from "../internal.js";
import { type Account } from "./account.js";
import { CoFeedEntry } from "./coFeed.js";
import { type CoKeys } from "./coMap.js";
import { type CoValue, type ID } from "./interfaces.js";
/**
 * Returns a boolean for whether the given type is a union.
 *
 * Taken from https://github.com/sindresorhus/type-fest/blob/main/source/is-union.d.ts
 */
type IsUnion<T, U = T> = ([
    T
] extends [never] ? false : T extends any ? [U] extends [T] ? false : true : never) extends infer Result ? boolean extends Result ? true : Result : never;
/**
 * A CoValue that may or may not be loaded.
 */
export type MaybeLoaded<T> = T | NotLoaded<T>;
/**
 * A CoValue that is either successfully loaded or that could not be loaded.
 */
export type Settled<T> = T | Inaccessible<T>;
/**
 * A CoValue that is not loaded.
 */
export type NotLoaded<T> = {
    $jazz: {
        id: ID<T>;
        loadingState: typeof CoValueLoadingState.LOADING | typeof CoValueLoadingState.DELETED | typeof CoValueLoadingState.UNAVAILABLE | typeof CoValueLoadingState.UNAUTHORIZED;
    };
    $isLoaded: false;
};
/**
 * A CoValue that is being loaded
 */
export type Loading<T> = {
    $jazz: {
        id: ID<T>;
        loadingState: typeof CoValueLoadingState.LOADING;
    };
    $isLoaded: false;
};
/**
 * A CoValue that could not be loaded
 */
export type Inaccessible<T> = {
    $jazz: {
        id: ID<T>;
        loadingState: typeof CoValueLoadingState.DELETED | typeof CoValueLoadingState.UNAVAILABLE | typeof CoValueLoadingState.UNAUTHORIZED;
    };
    $isLoaded: false;
};
/**
 * Narrows a maybe-loaded, optional CoValue to a loaded and required CoValue.
 */
export type LoadedAndRequired<T> = Exclude<T, NotLoaded<T> | undefined>;
/**
 * Narrows a maybe-loaded, optional CoValue to a loaded and optional CoValue
 */
export type AsLoaded<T> = Exclude<T, NotLoaded<T>>;
/**
 * By default, if a nested CoValue is not loaded, the parent CoValue will not be loaded either.
 * When `$onError: "catch"` is used, the parent CoValue will always be loaded, and an {@link NotLoaded}
 * value will be returned for the nested CoValue if it cannot be loaded.
 *
 * Use `$onError` to handle cases where some data you have requested is inaccessible,
 * similar to a `try...catch` block in your query.
 */
type OnError = {
    $onError?: "catch";
};
export type RefsToResolve<V, DepthLimit extends number = 10, CurrentDepth extends number[] = []> = boolean | (DepthLimit extends CurrentDepth["length"] ? any : V extends ReadonlyArray<infer Item> ? LoadedAndRequired<Item> extends CoValue ? ({
    $each?: RefsToResolve<AsLoaded<Item>, DepthLimit, [
        0,
        ...CurrentDepth
    ]>;
} & OnError) | boolean : OnError | boolean : V extends {
    [TypeSym]: "CoMap" | "Group" | "Account";
} ? ({
    [Key in CoKeys<V> as LoadedAndRequired<V[Key]> extends CoValue ? Key : never]?: RefsToResolve<LoadedAndRequired<V[Key]>, DepthLimit, [
        0,
        ...CurrentDepth
    ]>;
} & OnError) | (ItemsSym extends keyof V ? {
    $each: RefsToResolve<LoadedAndRequired<V[ItemsSym]>, DepthLimit, [
        0,
        ...CurrentDepth
    ]>;
} & OnError : never) | boolean : V extends {
    [TypeSym]: "CoStream";
    byMe: CoFeedEntry<infer Item> | undefined;
} ? ({
    $each: RefsToResolve<AsLoaded<Item>, DepthLimit, [
        0,
        ...CurrentDepth
    ]>;
} & OnError) | boolean : V extends {
    [TypeSym]: "CoPlainText" | "BinaryCoStream";
} ? boolean | OnError : V extends {
    [TypeSym]: "SnapshotRef";
    ref: infer Item;
} ? ({
    ref: RefsToResolve<AsLoaded<Item>, DepthLimit, [
        0,
        ...CurrentDepth
    ]>;
} & OnError) | boolean : boolean);
export type RefsToResolveStrict<T, V> = [V] extends [RefsToResolve<T>] ? RefsToResolve<T> : V;
export type Resolved<T, R extends RefsToResolve<T> | undefined = true> = DeeplyLoaded<T, R>;
/**
 * If the resolve query contains `$onError: "catch"`, we return a not loaded value for this nested CoValue.
 * Otherwise, the whole load operation returns a not-loaded value.
 */
type OnErrorResolvedValue<V, Depth> = Depth extends {
    $onError: "catch";
} ? NotLoaded<V> : never;
type CoMapLikeLoaded<V extends object, Depth, DepthLimit extends number, CurrentDepth extends number[]> = IsUnion<LoadedAndRequired<V>> extends true ? V extends V ? CoMapLikeLoaded<V, Pick<Depth, keyof V & keyof Depth>, DepthLimit, CurrentDepth> : never : {
    readonly [Key in keyof Omit<Depth, "$onError">]-?: Key extends CoKeys<V> ? LoadedAndRequired<V[Key]> extends CoValue ? DeeplyLoaded<LoadedAndRequired<V[Key]>, Depth[Key], DepthLimit, [
        0,
        ...CurrentDepth
    ]> | (undefined extends V[Key] ? undefined : never) | OnErrorResolvedValue<V[Key], Depth[Key]> : never : never;
} & V;
export type DeeplyLoaded<V, Depth, DepthLimit extends number = 10, CurrentDepth extends number[] = []> = DepthLimit extends CurrentDepth["length"] ? V : Depth extends true | undefined ? V : [
    V
] extends [ReadonlyArray<infer Item>] ? AsLoaded<Item & {}> extends CoValue ? Depth extends {
    $each: infer ItemDepth;
} ? // Deeply loaded CoList
ReadonlyArray<DeeplyLoaded<AsLoaded<Item>, ItemDepth, DepthLimit, [
    0,
    ...CurrentDepth
]> | OnErrorResolvedValue<AsLoaded<Item>, Depth["$each"]>> & V : never : V : [
    V
] extends [{
    [TypeSym]: "CoMap" | "Group" | "Account";
}] ? keyof Depth extends never ? V : ItemsSym extends keyof V ? Depth extends {
    $each: infer ItemDepth;
} ? {
    readonly [key: string]: DeeplyLoaded<LoadedAndRequired<V[ItemsSym]>, ItemDepth, DepthLimit, [
        0,
        ...CurrentDepth
    ]> | OnErrorResolvedValue<LoadedAndRequired<V[ItemsSym]>, Depth["$each"]>;
} & V : string extends keyof Depth ? // if at least one key is `string`, then we treat the resolve as it was empty
DeeplyLoaded<V, {}, DepthLimit, [0, ...CurrentDepth]> & V : CoMapLikeLoaded<V, Depth, DepthLimit, CurrentDepth> : CoMapLikeLoaded<V, Depth, DepthLimit, CurrentDepth> : [V] extends [
    {
        [TypeSym]: "SnapshotRef";
        ref: infer Item;
    }
] ? Depth extends {
    ref: infer ItemDepth;
} ? {
    readonly ref: DeeplyLoaded<AsLoaded<Item>, ItemDepth, DepthLimit, [
        0,
        ...CurrentDepth
    ]> | OnErrorResolvedValue<AsLoaded<Item>, ItemDepth>;
} & V : V : [V] extends [
    {
        [TypeSym]: "CoStream";
        byMe: CoFeedEntry<infer Item> | undefined;
    }
] ? // Deeply loaded CoStream
{
    byMe?: {
        value: AsLoaded<Item>;
    };
    inCurrentSession?: {
        value: AsLoaded<Item>;
    };
    perSession: {
        [key: SessionID]: {
            value: AsLoaded<Item>;
        };
    };
} & {
    [key: ID<Account>]: {
        value: AsLoaded<Item>;
    };
} & V : [V] extends [
    {
        [TypeSym]: "BinaryCoStream";
    }
] ? V : [V] extends [
    {
        [TypeSym]: "CoPlainText";
    }
] ? V : never;
export {};
//# sourceMappingURL=deepLoading.d.ts.map