import { EnumShape, ShapeVisitor, TypeShape, UnionShape, Value } from '@punchcard/shape';
import { ArrayShape, MapShape, SetShape } from '@punchcard/shape/lib/collection';
import { AnyShape, BinaryShape, BoolShape, NothingShape, NumberShape, StringShape, TimestampShape } from '@punchcard/shape/lib/primitive';
import { Shape } from '@punchcard/shape/lib/shape';
import { AttributeValue } from './attribute';
import { Writer } from './writer';
export declare namespace DSL {
    type Tag = typeof Tag;
    const Tag: unique symbol;
    type Of<T extends Shape> = T extends BinaryShape ? DSL.Binary : T extends BoolShape ? DSL.Bool : T extends AnyShape ? DSL.Any<T> : T extends NumberShape ? DSL.Number : T extends StringShape ? DSL.String : T extends TimestampShape ? DSL.Timestamp : T extends UnionShape<infer U> ? U extends 1 ? {
        [i in Extract<keyof U, number>]: Of<U[i]>;
    }[1] : NothingShape extends Extract<U[Extract<keyof U, number>], NothingShape> ? U['length'] extends 1 ? DSL.Object<NothingShape> : U['length'] extends 2 ? Exclude<{
        [i in Extract<keyof U, number>]: Of<U[i]>;
    }[Extract<keyof U, number>], DSL.Object<NothingShape>> : DSL.Union<T> : DSL.Union<T> : T extends EnumShape ? Enum<T> : T extends TypeShape<any> ? DSL.Struct<T> : T extends MapShape<infer V> ? DSL.Map<V> : T extends SetShape<infer I> ? DSL.Set<I> : T extends ArrayShape<infer I> ? DSL.List<I> : T extends {
        [Tag]: infer Q;
    } ? Q : DSL.Object<T>;
    type Root<T extends TypeShape<any>> = Struct<T>['fields'];
    function of<T extends TypeShape<any>>(shape: T): Root<T>;
    function _of<T extends Shape>(shape: T, expr: ExpressionNode<any>): Of<T>;
    const DslVisitor: ShapeVisitor<Node, ExpressionNode<any>>;
}
export declare namespace DSL {
    const isNode: (a: any) => a is Node<string>;
    type Expression<T extends Shape> = ExpressionNode<T> | Value.Of<T>;
    const NodeType: unique symbol;
    const SubNodeType: unique symbol;
    const DataType: unique symbol;
    const InstanceExpression: unique symbol;
    const Synthesize: unique symbol;
    abstract class Node<T extends string = string> {
        readonly [NodeType]: T;
        constructor(nodeType: T);
        abstract [Synthesize](writer: Writer): void;
    }
    function isStatementNode(a: any): a is StatementNode;
    abstract class StatementNode extends Node<'statement'> {
        abstract [SubNodeType]: string;
        constructor();
    }
    abstract class ExpressionNode<S extends Shape> extends Node<'expression'> {
        readonly [DataType]: S;
        abstract readonly [SubNodeType]: string;
        constructor(shape: S);
    }
    class Id extends ExpressionNode<StringShape> {
        readonly value: string;
        readonly [SubNodeType] = "identifier";
        constructor(value: string);
        [Synthesize](writer: Writer): void;
    }
    function isLiteral(a: any): a is Literal<any>;
    class Literal<T extends Shape> extends ExpressionNode<T> {
        readonly value: Value.Of<AttributeValue.ShapeOf<T>>;
        readonly [SubNodeType] = "literal";
        constructor(type: T, value: Value.Of<AttributeValue.ShapeOf<T>>);
        [Synthesize](writer: Writer): void;
    }
    class RootProperty<T extends Shape> extends ExpressionNode<T> {
        readonly name: string;
        [SubNodeType]: string;
        constructor(type: T, name: string);
        [Synthesize](writer: Writer): void;
    }
    class FunctionCall<T extends Shape> extends ExpressionNode<T> {
        readonly name: string;
        readonly returnType: T;
        readonly parameters: ExpressionNode<any>[];
        [SubNodeType]: string;
        constructor(name: string, returnType: T, parameters: ExpressionNode<any>[]);
        [Synthesize](writer: Writer): void;
    }
    class Object<T extends Shape> extends ExpressionNode<T> {
        readonly [SubNodeType] = "object";
        readonly [InstanceExpression]: ExpressionNode<T>;
        constructor(type: T, instanceExpression: ExpressionNode<T>);
        [Synthesize](writer: Writer): void;
        equals(other: Expression<T>): Bool;
        get size(): Number;
        set(value: Expression<T> | Computation<T>): Action;
        exists(): Bool;
        notExists(): Bool;
    }
    namespace Object {
        function beginsWith(lhs: Expression<StringShape>, rhs: Expression<StringShape>): Bool;
        class Assign<T extends Shape> extends StatementNode {
            private readonly instance;
            private readonly value;
            [SubNodeType]: string;
            constructor(instance: Object<T>, value: Node);
            [Synthesize](writer: Writer): void;
        }
        abstract class Comparison<T extends Shape, U extends Shape> extends ExpressionNode<BoolShape> {
            readonly left: ExpressionNode<T>;
            readonly right: ExpressionNode<U>;
            protected abstract operator: string;
            constructor(left: ExpressionNode<T>, right: ExpressionNode<U>);
            [Synthesize](writer: Writer): void;
        }
        class Equals<T extends Shape> extends Object.Comparison<T, T> {
            protected readonly operator: '=';
            readonly [SubNodeType] = "equals";
        }
    }
    function size(path: Object<any>): Size;
    class Size extends FunctionCall<NumberShape> {
        constructor(path: Object<any>);
    }
    class Bool extends Object<BoolShape> {
        constructor(expression: ExpressionNode<BoolShape>, boolShape?: BoolShape);
        and(...conditions: Expression<BoolShape>[]): Bool;
        or(...conditions: Expression<BoolShape>[]): Bool;
        not(): Bool;
    }
    namespace Bool {
        abstract class Operands extends ExpressionNode<BoolShape> {
            readonly operands: ExpressionNode<BoolShape>[];
            abstract readonly operator: string;
            constructor(operands: ExpressionNode<BoolShape>[]);
            [Synthesize](writer: Writer): void;
        }
        class And extends Operands {
            readonly operator = "AND";
            [SubNodeType]: 'and';
        }
        class Or extends Operands {
            readonly operator = "OR";
            [SubNodeType]: 'or';
        }
        class Not extends ExpressionNode<BoolShape> {
            readonly operand: ExpressionNode<BoolShape>;
            [SubNodeType]: 'not';
            constructor(operand: ExpressionNode<BoolShape>);
            [Synthesize](writer: Writer): void;
        }
    }
    function or(...operands: ExpressionNode<BoolShape>[]): Bool;
    function and(...operands: ExpressionNode<BoolShape>[]): Bool;
    function not(operand: ExpressionNode<BoolShape>): Bool;
    class Ord<T extends Shape> extends Object<T> {
        greaterThan(other: Expression<NumberShape>): Bool;
        greaterThanOrEqual(other: Expression<NumberShape>): Bool;
        lessThan(other: Expression<NumberShape>): Bool;
        lessThanOrEqual(other: Expression<NumberShape>): Bool;
        between(lowerBound: Expression<T>, upperBound: Expression<T>): Bool;
    }
    namespace Ord {
        class Gt<T extends Shape> extends Object.Comparison<T, NumberShape> {
            protected readonly operator: '>';
            readonly [SubNodeType] = "greaterThan";
        }
        class Gte<T extends Shape> extends Object.Comparison<T, NumberShape> {
            protected readonly operator: '>=';
            readonly [SubNodeType] = "greaterThanOrEqual";
        }
        class Lt<T extends Shape> extends Object.Comparison<T, NumberShape> {
            protected readonly operator: '<';
            readonly [SubNodeType] = "lessThan";
        }
        class Lte<T extends Shape> extends Object.Comparison<T, NumberShape> {
            protected readonly operator: '<=';
            readonly [SubNodeType] = "lessThanOrEqual";
        }
        class Between<T extends Shape> extends ExpressionNode<BoolShape> {
            readonly lhs: ExpressionNode<T>;
            readonly lowerBound: ExpressionNode<T>;
            readonly upperBound: ExpressionNode<T>;
            readonly [SubNodeType] = "between";
            constructor(lhs: ExpressionNode<T>, lowerBound: ExpressionNode<T>, upperBound: ExpressionNode<T>);
            [Synthesize](writer: Writer): void;
        }
    }
    function isComputation(a: any): a is Computation<any>;
    /**
     * Computations are not Expressions, although they do represent a value.
     *
     * This is because they are not usable within Query or Filter expressions.
     *
     * E.g. this is impossible:
     * ```
     * table.putIf(.., item => item.plus(1).equals(2))
     * ```
     */
    abstract class Computation<T extends Shape> extends StatementNode {
        readonly lhs: ExpressionNode<T>;
        readonly rhs: ExpressionNode<T>;
        readonly [SubNodeType] = "computation";
        abstract readonly operator: string;
        constructor(lhs: ExpressionNode<T>, rhs: ExpressionNode<T>);
        [Synthesize](writer: Writer): void;
    }
    class ComputationExpression<T extends Shape> extends ExpressionNode<T> {
        readonly computation: Computation<T>;
        [SubNodeType]: string;
        constructor(shape: T, computation: Computation<T>);
        [Synthesize](writer: Writer): void;
    }
    enum ActionType {
        SET = "SET"
    }
    class Action {
        readonly actionType: ActionType;
        readonly statement: StatementNode;
        constructor(actionType: ActionType, statement: StatementNode);
    }
    /**
     * Represents a number in a DynamoDB Filter, Query or Update expression.
     */
    class Number extends Ord<NumberShape> {
        constructor(expression: ExpressionNode<NumberShape>, shape?: NumberShape);
        decrement(value?: Expression<NumberShape>): Action;
        increment(value?: Expression<NumberShape>): Action;
        minus(value: Expression<NumberShape>): Number.Minus;
        plus(value: Expression<NumberShape>): Number.Plus;
    }
    namespace Number {
        class Plus extends Computation<NumberShape> {
            operator: '+';
        }
        class Minus extends Computation<NumberShape> {
            operator: '-';
        }
    }
    class Binary extends Object<BinaryShape> {
    }
    class StringLike<T extends StringShape | EnumShape> extends Ord<T> {
        beginsWith(value: Expression<StringShape>): Bool;
        get length(): Number;
    }
    class String extends StringLike<StringShape> {
        constructor(expression: ExpressionNode<StringShape>, shape?: StringShape);
    }
    namespace String {
        class BeginsWith extends FunctionCall<BoolShape> {
            readonly [SubNodeType] = "string-begins-with";
            constructor(lhs: ExpressionNode<StringShape | EnumShape>, rhs: ExpressionNode<StringShape | EnumShape>);
        }
        function beginsWith(lhs: Expression<StringShape | EnumShape>, rhs: Expression<StringShape | EnumShape>): Bool;
    }
    class Timestamp extends Object<TimestampShape> {
        constructor(expression: ExpressionNode<TimestampShape>, shape?: TimestampShape);
    }
    class Enum<E extends EnumShape> extends StringLike<E> {
    }
    class List<T extends Shape> extends Object<ArrayShape<T>> {
        constructor(type: ArrayShape<T>, expression: ExpressionNode<ArrayShape<T>>);
        [index: number]: Of<T>;
        get length(): Number;
        get(index: Expression<NumberShape>): Of<T>;
        push(item: Expression<T>): Action;
        concat(list: Expression<ArrayShape<T>>): Action;
    }
    namespace List {
        class Item<T extends Shape> extends ExpressionNode<T> {
            readonly list: List<T>;
            readonly index: ExpressionNode<NumberShape>;
            readonly [SubNodeType] = "list-item";
            constructor(list: List<T>, index: ExpressionNode<NumberShape>);
            [Synthesize](writer: Writer): void;
        }
        class Append<T extends Shape> extends FunctionCall<ArrayShape<T>> {
            readonly list: List<T>;
            readonly values: List<T>;
            [SubNodeType]: 'list-append';
            constructor(list: List<T>, values: List<T>);
        }
    }
    class Set<T extends Shape> extends Object<SetShape<T>> {
        contains(value: Expression<T>): Bool;
    }
    namespace Set {
        class Contains<T extends Shape> extends FunctionCall<BoolShape> {
            constructor(set: Set<T>, value: ExpressionNode<T>);
        }
    }
    class Map<T extends Shape> extends Object<MapShape<T>> {
        get(key: Expression<StringShape>): Of<T>;
        put(key: Expression<StringShape>, value: Expression<T>): Action;
    }
    namespace Map {
        class GetValue<T extends Shape> extends ExpressionNode<T> {
            readonly map: Map<T>;
            readonly key: ExpressionNode<StringShape>;
            readonly [SubNodeType] = "map-value";
            constructor(map: Map<T>, key: ExpressionNode<StringShape>);
            [Synthesize](writer: Writer): void;
        }
    }
    class Struct<T extends TypeShape<any>> extends Object<T> {
        readonly fields: {
            [fieldName in keyof T['Members']]: Of<T['Members'][fieldName]>;
        };
        constructor(type: T, expression: ExpressionNode<T>);
    }
    namespace Struct {
        class Field<T extends Shape> extends ExpressionNode<T> {
            readonly struct: Struct<any>;
            readonly name: string;
            readonly [SubNodeType] = "struct-field";
            constructor(struct: Struct<any>, type: T, name: string);
            [Synthesize](writer: Writer): void;
        }
    }
    class Any<T extends AnyShape> extends Object<T> {
        as<S extends Shape>(shape: S): DSL.Of<S>;
        equals(args: never): never;
        set(args: never): never;
    }
    class Union<T extends UnionShape<Shape[]>> extends Object<T> {
        as<S extends T['Items'][Extract<keyof T['Items'], number>]>(shape: S): DSL.Of<S>;
    }
}
//# sourceMappingURL=dsl.d.ts.map