import { Brand, Validation } from "@fncts/base/data/Branded";
import { Check } from "@fncts/typelevel";
import { Schema } from "@fncts/schema/Schema/definition";
import { LiteralValue, AST } from "@fncts/schema/AST";
import { Maybe } from "@fncts/base/data/Maybe/definition";
import { Vector } from "@fncts/base/collection/immutable/Vector";
import type { Union } from "@fncts/typelevel";
import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
/**
 * @tsplus derive fncts.schema.Schema<_> 10
 * @tsplus location "@fncts/schema/Schema/derivations"
 */
export declare function deriveValidation<A extends Brand.Valid<any, any>>(...[base, brands]: Check<Brand.IsValidated<A>> extends Check.True ? [
    base: Schema<Brand.Unbranded<A>>,
    brands: {
        [K in keyof A[Brand.valid] & string]: Validation<A[Brand.valid][K], K>;
    }
] : never): Schema<A>;
/**
 * @tsplus derive fncts.schema.Schema<_> 20
 * @tsplus location "@fncts/schema/Schema/derivations"
 */
export declare function deriveLiteral<A extends LiteralValue>(...[value]: Check<Check.IsLiteral<A> & Check.Not<Check.IsUnion<A>>> extends Check.True ? [value: A] : never): Schema<A>;
type MaybeKeys<A> = {
    [K in keyof A]: A[K] extends Maybe<any> ? K : never;
}[keyof A];
type IndexSignatures<A extends Record<PropertyKey, any>> = Union.ListOf<{
    [K in keyof A]: Check<Check.IsLiteral<K>> extends Check.True ? never : {
        key: Schema<K>;
        value: Schema<A[K]>;
    };
}[keyof A]>;
/**
 * @tsplus derive fncts.schema.Schema<_> 20
 * @tsplus location "@fncts/schema/Schema/derivations"
 */
export declare function deriveStruct<A extends Record<string, any>>(...[requiredFields, optionalFields, maybeFields, indexSchema]: Check<Check.IsStruct<A>> extends Check.True ? [
    ...[
        requiredFields: {
            [k in Exclude<RequiredKeys<A>, MaybeKeys<A>>]: Schema<A[k]>;
        }
    ],
    ...([OptionalKeys<A>] extends [never] ? [optionalFields: {}] : [
        optionalFields: {
            [k in OptionalKeys<A>]: Schema<A[k]>;
        }
    ]),
    ...([MaybeKeys<A>] extends [never] ? [maybeFields: {}] : [
        maybeFields: {
            [k in MaybeKeys<A>]: [A[k]] extends [Maybe<infer _A>] ? Schema<_A> : never;
        }
    ]),
    ...[indexSchema: IndexSignatures<A>]
] : never): Schema<A>;
/**
 * @tsplus derive fncts.schema.Schema<_> 10
 * @tsplus location "@fncts/schema/Schema/derivations"
 */
export declare function deriveTuple<A extends ReadonlyArray<any>>(...[components]: Check<Check.IsTuple<A>> extends Check.True ? [components: {
    [K in keyof A]: Schema<A[K]>;
}] : never): Schema<A>;
/**
 * @tsplus derive fncts.schema.Schema lazy
 * @tsplus location "@fncts/schema/Schema/derivations"
 */
export declare function deriveLazy<A>(f: (_: Schema<A>) => Schema<A>): Schema<A>;
/**
 * @tsplus derive fncts.schema.Schema[fncts.ReadonlyArray]<_> 10
 * @tsplus location "@fncts/schema/Schema/derivations"
 */
export declare function deriveReadonlyArray<A extends ReadonlyArray<any>>(...[element]: [A] extends [ReadonlyArray<infer _A>] ? Check<Check.IsEqual<A, ReadonlyArray<_A>>> extends Check.True ? [element: Schema<_A>] : never : never): Schema<A>;
/**
 * @tsplus derive fncts.schema.Schema[fncts.Array]<_> 10
 * @tsplus location "@fncts/schema/Schema/derivations"
 */
export declare function deriveArray<A extends Array<any>>(...[element]: [A] extends [Array<infer _A>] ? Check<Check.IsEqual<A, Array<_A>>> extends Check.True ? [element: Schema<_A>] : never : never): Schema<A>;
/**
 * @tsplus derive fncts.schema.Schema<_> 15
 * @tsplus location "@fncts/schema/Schema/derivations"
 */
export declare function deriveRecord<A extends Record<string | symbol, any>>(...[keySchema, valueSchema]: [A] extends [Record<infer X, infer Y>] ? Check<Check.Not<Check.IsUnion<A>> & Check.IsEqual<A, Record<X, Y>>> extends Check.True ? [keySchema: Schema<X>, valueSchema: Schema<Y>] : never : never): Schema<A>;
export {};