import { AnyShape, ArrayShape, AssertIsShape, BinaryShape, BoolShape, EnumShape, LiteralShape, MapShape, NothingShape, NumberShape, SetShape, Shape, StringShape, TimestampShape, UnionShape } from '@punchcard/shape';
import { TypeClass, TypeShape } from '@punchcard/shape/lib/type';
export declare namespace AttributeValue {
    type Tag = typeof Tag;
    const Tag: unique symbol;
    interface ShapeOfProps {
        /**
         * Will represent all sets as lists.
         * @default false
         */
        setAsList?: boolean;
    }
    type ShapeOf<T extends Shape, Props extends ShapeOfProps = {
        setAsList: false;
    }> = T extends StringShape | TimestampShape ? typeof AttributeValue.String : T extends EnumShape ? AttributeValue.Enum<T> : T extends NumberShape ? typeof AttributeValue.Number : T extends BoolShape ? typeof AttributeValue.Bool : T extends BinaryShape ? typeof AttributeValue.Binary : T extends NothingShape ? typeof AttributeValue.Nothing : T extends AnyShape ? AnyShape : T extends ArrayShape<infer I> ? AttributeValue.List<ShapeOf<I, Props>> : T extends MapShape<infer V> ? AttributeValue.Map<ShapeOf<V, Props>> : T extends SetShape<infer I> ? Props['setAsList'] extends true ? AttributeValue.List<ShapeOf<I, Props>> : I extends BinaryShape ? typeof AttributeValue.BinarySet : I extends StringShape ? typeof AttributeValue.StringSet : I extends NumberShape ? typeof AttributeValue.NumberSet : AttributeValue.List<ShapeOf<I, Props>> : T extends TypeShape<infer Fields> ? AttributeValue.Struct<{
        [field in keyof Fields]: ShapeOf<Fields[field], Props>;
    }> : T extends UnionShape<infer I> ? UnionShape<{
        [i in keyof I]: ShapeOf<AssertIsShape<I[i]>, Props>;
    }> : T extends LiteralShape<infer I> ? {
        [i in keyof I]: ShapeOf<I, Props>;
    }[keyof I] : T extends {
        [Tag]: infer T2;
    } ? T2 : AnyShape;
    /**
     * Derives a shape representing `T` in DynamoDB JSON.
     *
     * @param shape to derive a DynamoDB Shape for.
     */
    function shapeOf<T extends Shape, Props extends ShapeOfProps = {
        readonly setAsList: false;
    }>(shape: T, props?: Props): ShapeOf<T>;
}
export declare type AttributeValue = (AnyShape | typeof AttributeValue.Nothing | typeof AttributeValue.Binary | typeof AttributeValue.BinarySet | typeof AttributeValue.Bool | typeof AttributeValue.Number | typeof AttributeValue.NumberSet | typeof AttributeValue.String | typeof AttributeValue.StringSet | AttributeValue.List<AttributeValue> | AttributeValue.Map<AttributeValue> | AttributeValue.Struct<AttributeValue.StructFields>);
export declare namespace AttributeValue {
    const Nothing_base: TypeClass<{
        NULL: LiteralShape<BoolShape, true>;
    }, undefined>;
    export class Nothing extends Nothing_base {
    }
    const Binary_base: TypeClass<{
        B: BinaryShape;
    }, undefined>;
    export class Binary extends Binary_base {
    }
    const BinarySet_base: TypeClass<{
        BS: ArrayShape<BinaryShape>;
    }, undefined>;
    export class BinarySet extends BinarySet_base {
    }
    const Bool_base: TypeClass<{
        BOOL: BoolShape;
    }, undefined>;
    export class Bool extends Bool_base {
    }
    const Number_base: TypeClass<{
        N: StringShape;
    }, undefined>;
    export class Number extends Number_base {
    }
    const NumberSet_base: TypeClass<{
        NS: ArrayShape<StringShape>;
    }, undefined>;
    export class NumberSet extends NumberSet_base {
    }
    const String_base: TypeClass<{
        S: StringShape;
    }, undefined>;
    export class String extends String_base {
    }
    export interface Enum<E extends EnumShape> {
        S: E;
    }
    export const Enum: <E extends EnumShape<import("@punchcard/shape").EnumValues, string | undefined>>(e: E) => TypeClass<{
        S: E;
    }, undefined>;
    const StringSet_base: TypeClass<{
        SS: ArrayShape<StringShape>;
    }, undefined>;
    export class StringSet extends StringSet_base {
    }
    export interface List<T extends AttributeValue> extends TypeShape<{
        L: ArrayShape<T>;
    }> {
    }
    export const List: <T extends AttributeValue>(item: T) => List<T>;
    export interface Map<T extends AttributeValue> extends TypeClass<{
        M: MapShape<T>;
    }> {
    }
    export const Map: <T extends AttributeValue>(item: T) => Map<T>;
    export interface StructFields {
        [fieldName: string]: AttributeValue;
    }
    export interface Struct<F extends StructFields> extends TypeClass<{
        M: TypeShape<F>;
    }> {
    }
    export const Struct: <F extends StructFields>(fields: F) => Struct<F>;
    export {};
}
//# sourceMappingURL=attribute.d.ts.map