import { AllRequired, InferredType, KeysOf, Primitive } from 'tsds-tools';
/**
 * Unwrap T[] (and readonly T[]) to T. Leave non-arrays unchanged.
 */
type UnwrapArray<T> = T extends readonly (infer U)[] ? U : T;
/**
 * `[T]` tuple-wrap blocks distribution over unions, so `string | null`
 * is tested as a whole (primitive) instead of element-wise.
 */
type IsRelation<T> = [T] extends [Primitive | null | undefined] ? false : [T] extends [object] ? true : false;
/**
 * Depth counter. Index into Prev with current depth to get depth-1.
 * Tuple lookup is O(1) at type-check time.
 */
type Prev = [never, 0, 1, 2, 3, 4, 5];
/**
 * Recursive depth-capped nested key extractor.
 * Replaces NestedKeysOf and NestedKeysOf2 with a single body.
 */
type NestedKeysUpTo<Entity, Depth extends number, Type> = Depth extends 0 ? never : {
    [Key in keyof AllRequired<Entity>]: UnwrapArray<AllRequired<Entity>[Key]> extends infer V ? IsRelation<V> extends true ? `${Key & string}.${KeysOf<V, Type> & string}` | `${Key & string}.${NestedKeysUpTo<V, Prev[Depth], Type> & string}` : never : never;
}[keyof AllRequired<Entity>];
/**
 * Extracts nested paths for relations (1 level deep).
 *
 * @example
 * type Post = { id: string; author: User }
 * type User = { id: string; name: string }
 * type Result = NestedKeysOf<Post, NonArrayPrimitive>
 * // Result = 'author.id' | 'author.name'
 */
export type NestedKeysOf<Entity, Type = any> = NestedKeysUpTo<Entity, 1, Type>;
/**
 * Extracts nested paths for 2 levels deep.
 *
 * @example
 * type Post = { id: string; author: User }
 * type User = { id: string; profile: UserProfile }
 * type UserProfile = { bio: string; age: number }
 * type Result = NestedKeysOf2<Post, NonArrayPrimitive>
 * // Result = 'author.id' | 'author.name' | 'author.profile.bio' | 'author.profile.age'
 */
export type NestedKeysOf2<Entity, Type = any> = NestedKeysUpTo<Entity, 2, Type>;
/**
 * 1-level nested keys alias.
 */
export type AllNestedKeysOf<Entity, Type = any> = NestedKeysOf<Entity, Type>;
/**
 * Combined 1+2 level nested keys.
 */
export type AllNestedKeysOf2<Entity, Type = any> = NestedKeysOf2<Entity, Type>;
/**
 * Get the leaf type at a nested path.
 *
 * @example
 * type Post = { id: string; author: User }
 * type User = { id: string; name: string }
 * type Result = TypeOfNested<Post, 'author.id'>
 * // Result = string
 */
export type TypeOfNested<Entity, Path extends string> = Path extends `${infer K}.${infer Rest}` ? K extends keyof AllRequired<Entity> ? UnwrapArray<AllRequired<Entity>[K]> extends infer V ? Rest extends keyof AllRequired<V> ? AllRequired<V>[Rest] : TypeOfNested<V, Rest> : never : never : Path extends keyof AllRequired<Entity> ? AllRequired<Entity>[Path] : never;
/**
 * Direct keys + 1-level nested.
 */
export type DirectOrNestedKeysOf<Entity, Type = any> = KeysOf<Entity, Type> | NestedKeysOf<Entity, Type>;
/**
 * Direct keys + 1-level + 2-level nested.
 */
export type DirectOrNestedKeysOf2<Entity, Type = any> = KeysOf<Entity, Type> | NestedKeysOf2<Entity, Type>;
/**
 * True if T is a dotted path.
 */
export type IsNestedPath<T extends string> = T extends `${string}.${string}` ? true : false;
/**
 * Extract the relation prefix of a dotted path.
 *
 * @example
 * RelationOf<'author.profile.bio'>  // 'author.profile'
 */
export type RelationOf<Path extends string> = Path extends `${infer Relation}.${infer _Field}` ? _Field extends `${string}.${string}` ? `${Relation}.${RelationOf<_Field>}` : Relation : never;
/**
 * Nested 2-segment paths that END on a relation (not primitive leaf).
 * Used for whereJoin-style ops.
 */
export type NestedRelationKeysOf<Entity> = {
    [Key in keyof AllRequired<Entity>]: UnwrapArray<AllRequired<Entity>[Key]> extends infer V ? IsRelation<V> extends true ? {
        [Key2 in keyof AllRequired<V>]: UnwrapArray<AllRequired<V>[Key2]> extends infer V2 ? IsRelation<V2> extends true ? `${Key & string}.${Key2 & string}` : never : never;
    }[keyof AllRequired<V>] : never : never;
}[keyof AllRequired<Entity>];
/**
 * Get the inferred entity type at a nested relation path
 * (unwrapped from array if needed).
 */
export type InferredNestedType<Entity, Path extends string> = Path extends `${infer K}.${infer Rest}` ? K extends keyof AllRequired<Entity> ? InferredNestedType<InferredType<Entity, K>, Rest> : never : Path extends keyof AllRequired<Entity> ? InferredType<Entity, Path> : never;
export {};