import { CamelCase } from "type-fest";
import { ZodRawShape } from "zod/lib/types";
import { ZodDiscriminatedUnion, ZodLiteral, ZodObject } from "zod";
import { EntityCore, EntityCoreShape, EntityCoreShapeType, Extender, UnsafeZentity, Zentity, ZodShapeType } from "./zentity";
import { Clean, ValueUnion } from "./utils";
type ExtractType<T, D extends string> = T extends {
    [K in D]: infer V;
} ? {
    [K in keyof T]: K extends D ? V : T[K];
} : never;
export type VariantsShape<S extends ZodRawShape> = Record<string, S>;
export type KeyedExtender<B extends ZodRawShape, KS extends VariantsShape<any>, R extends object> = {
    [K in keyof KS]?: Extender<KS[K] & B, R>;
};
type Flatten<O extends VariantsShape<ZodRawShape>, D extends string> = ValueUnion<{
    [K in keyof O]: ZodShapeType<O[K]> & {
        [Q in D]: K;
    };
}>;
type CamelCaseOf<P extends string, K extends string> = CamelCase<`${P}-${K}`>;
type VariantShape<BASE_SHAPE extends ZodRawShape, VARIANTS_SHAPE extends VariantsShape<ZodRawShape>, VARIANT_KEY extends keyof VARIANTS_SHAPE> = VARIANTS_SHAPE[VARIANT_KEY] & Clean<BASE_SHAPE>;
type VariantType<BASE_SHAPE extends ZodRawShape, VARIANTS_SHAPE extends VariantsShape<ZodRawShape>, VARIANT_KEY extends keyof VARIANTS_SHAPE> = ZodShapeType<VariantShape<BASE_SHAPE, VARIANTS_SHAPE, VARIANT_KEY>>;
type ReturnType<E> = E extends (arg: any) => infer R ? R : {};
type ToZodD<BS extends ZodRawShape, KS extends VariantsShape<any>, D extends string> = ZodObject<ValueUnion<{
    [key in keyof KS]: KS[key] & {
        [K in D]: ZodLiteral<any>;
    };
}> & BS & EntityCoreShapeType>;
type PolymorphicNewFn<BS extends ZodRawShape, KS extends VariantsShape<ZodRawShape>, D extends string, KSE extends KeyedExtender<BS, KS, any>> = {
    [key in (keyof KS & string) as CamelCaseOf<`new`, key>]: (params: VariantType<BS, KS, key> & {
        id: string;
    }) => PolymorphicEntityType<BS, KS, D, KSE, key>;
};
type PolymorphicCreateFn<BS extends ZodRawShape, KS extends VariantsShape<ZodRawShape>, D extends string, KSE extends KeyedExtender<BS, KS, any>> = {
    [key in (keyof KS & string) as CamelCaseOf<`create`, key>]: (params: VariantType<BS, KS, key> & EntityCore) => PolymorphicEntityType<BS, KS, D, KSE, key>;
};
type PolymorphicUnsafeFn<BS extends ZodRawShape, KS extends VariantsShape<ZodRawShape>, D extends string, KSE extends KeyedExtender<BS, KS, any>> = {
    [key in (keyof KS & string) as CamelCaseOf<`unsafe`, key>]: (params: VariantType<BS, KS, key> & EntityCore) => UnsafePolymorphicEntityType<BS, KS, D, KSE, key>;
};
type PolymorphicGuardFn<BS extends ZodRawShape, KS extends VariantsShape<ZodRawShape>, D extends string, KSE extends KeyedExtender<BS, KS, any>> = {
    [key in (keyof KS & string) as CamelCaseOf<'is', key>]: (data: any) => data is PolymorphicEntityType<BS, KS, D, KSE, key>;
};
type PolymorphicShape<BS extends ZodRawShape, KS extends VariantsShape<ZodRawShape>, D extends string> = {
    [key in (keyof KS & string) as CamelCaseOf<key, 'shape'>]: VariantShape<BS, KS, key> & {
        [K in D]: ZodLiteral<key>;
    } & typeof EntityCoreShape;
};
type PolymorphicSchema<BS extends ZodRawShape, KS extends VariantsShape<ZodRawShape>, D extends string> = {
    [key in (keyof KS & string) as CamelCaseOf<key, 'schema'>]: ZodObject<VariantShape<BS, KS, key> & {
        [K in D]: ZodLiteral<key>;
    } & typeof EntityCoreShape>;
};
type PolymorphicEntityType<BS extends ZodRawShape, KS extends VariantsShape<ZodRawShape>, D extends string, KE extends KeyedExtender<BS, KS, any>, key extends keyof KS> = Zentity<{
    [Q in D]: key;
} & VariantType<BS, KS, key>, ReturnType<KE[key]>>;
type UnsafePolymorphicEntityType<BS extends ZodRawShape, KS extends VariantsShape<ZodRawShape>, D extends string, KE extends KeyedExtender<BS, KS, any>, key extends keyof KS> = UnsafeZentity<{
    [Q in D]: key;
} & VariantType<BS, KS, key>, ReturnType<KE[key]>>;
export type PolymorphicEntityClass<BS extends ZodRawShape, KS extends VariantsShape<ZodRawShape>, D extends string, KE extends KeyedExtender<BS, KS, any>> = {
    name: string;
    create: <T extends Flatten<KS, D>>(params: T & EntityCore & ZodShapeType<BS>) => Zentity<ZodShapeType<BS> & ExtractType<T, D>, ReturnType<KE[T[D]]>>;
    new: <T extends Flatten<KS, D>>(params: T & ZodShapeType<BS> & {
        id: string;
    }) => Zentity<ExtractType<T, D>, ReturnType<KE[T[D]]>>;
    unsafe: <T extends Flatten<KS, D>>(params: T & ZodShapeType<BS>) => UnsafeZentity<ExtractType<T, D>, ReturnType<KE[T[D]]>>;
    baseShape: BS & typeof EntityCoreShape;
    schema: ZodDiscriminatedUnion<D, [ToZodD<BS, KS, D>, ...ToZodD<BS, KS, D>[]]>;
    variants: (keyof KS)[];
} & PolymorphicNewFn<BS, KS, D, KE> & PolymorphicCreateFn<BS, KS, D, KE> & PolymorphicUnsafeFn<BS, KS, D, KE> & PolymorphicGuardFn<BS, KS, D, KE> & PolymorphicSchema<BS, KS, D> & PolymorphicShape<BS, KS, D>;
export declare function polymorphicEntity<BS extends ZodRawShape, KS extends VariantsShape<ZodRawShape>, D extends string, KSE extends KeyedExtender<BS, KS, any>>(options: {
    name: string;
    discriminator: D;
    base: BS;
    variants: KS;
    extend: KSE;
}): PolymorphicEntityClass<BS, KS, D, KSE>;
type UnionOfStateShapeTypesWithDiscriminator<KS extends VariantsShape<ZodRawShape>, D extends string> = ValueUnion<{
    [key in keyof KS]: ZodShapeType<KS[key]> & {
        [Q in D]: key;
    };
}>;
export type inferPolymorphicEntityTypeFromClass<T> = T extends PolymorphicEntityClass<infer BS, infer KS, infer D, infer KE> ? Zentity<UnionOfStateShapeTypesWithDiscriminator<KS, D> & ZodShapeType<Clean<BS>>, ReturnType<KE[keyof KS]>> : never;
export type inferSpecificPolymorphicEntityTypeFromClass<T extends {
    variants: any;
}, K extends T['variants'][number]> = T extends PolymorphicEntityClass<infer BS, infer KS, infer D, infer KE> ? K extends keyof KS ? Zentity<ZodShapeType<KS[K]> & ZodShapeType<BS>, ReturnType<KE[K]>> : never : never;
export {};
//# sourceMappingURL=polymorphic-entity.d.ts.map