import ts from 'typescript';
export declare type LiteralValue = ts.Expression | ObjectLiteralValue | string | number | boolean | null;
export interface ObjectLiteralValue {
    [key: string]: LiteralValue;
}
export declare const Node: {
    /**
     * An identifier expression
     *
     * ```typescript
     * Node.Call({ expression: Node.Identifier('create'), args: [Node.Identifier('axiosConfig')] })
     * // Would generate
     * create(axiosConfig)
     * ```
     */
    Identifier: (name: string | ts.Identifier) => ts.Identifier;
    /**
     * Arrow function
     *
     * ```typescript
     * Node.Arrow({ args: [], body: Node.Literal({ value: 'something' }) })
     * // would generate
     * () => "something"
     * ```
     * A more complex example with a function block:
     * ```typescript
     * Node.Arrow({
     *   args: [Type.Param({ name: 'a', type: Type.Number })],
     *   body: Node.Block({
     *     statements: [
     *       Node.Return(Node.Call({ expression: Node.Identifier('otherFunction'), args: [Node.Identifier('a')] })),
     *     ],
     *   }),
     * }),
     * // would generate
     * (a: number) => { return otherFunction(a); }
     * ```
     */
    Arrow: ({ typeArgs, isAsync, args, ret, body, }: {
        typeArgs?: ts.TypeParameterDeclaration[] | undefined;
        args: ts.ParameterDeclaration[];
        ret?: ts.TypeNode | undefined;
        body: ts.ConciseBody;
        isAsync?: boolean | undefined;
    }) => ts.ArrowFunction;
    /**
     * A block of statements (code wrapped in "{" and "}"). Must contain items of type "statement"
     * ```typescript
     * Node.Block({
     *   statements: [
     *     Node.ExpressionStatement(Node.Call({ expression: Node.Identifier('one'), args: [] })),
     *     Node.ExpressionStatement(Node.Call({ expression: Node.Identifier('two'), args: [] })),
     *   ],
     * });
     * // would generate
     * {
     *   one();
     *   two();
     * }
     * ```
     */
    Block: ({ statements, multiline }: {
        statements: ts.Statement[];
        multiline?: boolean | undefined;
    }) => ts.Block;
    /**
     * Assignment
     * ```typescript
     * Node.Assignment(
     *   Node.Identifier('one'),
     *   Node.Literal(4)
     * );
     * // would generate
     * one = 4
     * ```
     */
    Assignment: (left: ts.Expression | ts.ObjectLiteralExpression | ts.ArrayLiteralExpression, right: ts.Expression) => ts.AssignmentExpression<ts.EqualsToken> | ts.DestructuringAssignment;
    /**
     * Await
     * ```typescript
     * Node.Await(
     *   Node.Call({ expression: Node.Identifier('one')}),
     * );
     * // would generate
     * await one();
     * ```
     */
    Await: (body: ts.Expression) => ts.AwaitExpression;
    /**
     * Create a generic expression statement.
     * ```typescript
     * Node.ExpressionStatement(Node.Call({ expression: Node.Identifier('one'), args: [] }))
     * // would generate
     * one();
     * ```
     */
    ExpressionStatement: (expression: ts.Expression) => ts.Statement;
    /**
     * A return statement
     * ```typescript
     * Node.Return(Node.Call({ expression: Node.Identifier('one'), args: [] }))
     * // would generate
     * return one();
     * ```
     */
    Return: (expression: ts.Expression) => ts.ReturnStatement;
    /**
     * A call expression
     *
     * ```typescript
     * Node.Call({ expression: Node.Identifier('otherFunction'), args: [Node.Identifier('a')] })
     * // would generate
     * otherFunction(a)
     * ```
     */
    Call: ({ expression, args, typeArgs, }: {
        expression: ts.LeftHandSideExpression;
        args?: ts.Expression[] | undefined;
        typeArgs?: ts.TypeNode[] | undefined;
    }) => ts.CallExpression;
    /**
     * An import declaration statement
     *
     * ```typescript
     * Node.Import({ defaultAs: 'Axios', module: 'axios' })
     * // would generate
     * import Axios from "axios";
     * ```
     * ```typescript
     * Node.Import({ allAs: 'axios', module: 'axios' })
     * // would generate
     * import * as axios from "axios";
     * ```
     * ```typescript
     * Node.Import({ named: [{ name: 'AxiosInstance' }, { name: 'AxiosRequestConfig' }], module: 'axios' })
     * // would generate
     * import { AxiosInstance, AxiosRequestConfig } from "axios";
     * ```
     * ```typescript
     * Node.Import({ named: [{ name: 'AxiosInstance', as: 'a' }], module: 'axios' })
     * // would generate
     * import { AxiosInstance as a } from "axios";
     * ```
     */
    Import: ({ named, allAs, defaultAs, module, }: {
        named?: {
            name: string | ts.Identifier;
            as?: string | undefined;
        }[] | undefined;
        defaultAs?: string | ts.Identifier | undefined;
        allAs?: string | undefined;
        module: string;
    }) => ts.ImportDeclaration;
    /**
     * Template string (backticks)
     * ```typescript
     * Node.TemplateString('test${var}')
     * // would generate
     * `test${var}`
     * ```
     */
    TemplateString: (text: string) => ts.TemplateLiteral;
    /**
     * Object literal ({ })
     * ```typescript
     * Node.ObjectLiteral({ props: [Node.ObjectLiteralProp({ key: 'test', value: 10 })] })
     * // would generate
     * { test: 10 }
     * ```
     */
    ObjectLiteral: ({ jsDoc, props, multiline, }: {
        jsDoc?: string | undefined;
        props: ts.PropertyAssignment[];
        multiline?: boolean | undefined;
    }) => ts.ObjectLiteralExpression;
    /**
     * Property for object literal
     * ```typescript
     * Node.ObjectLiteral({ props: [Node.ObjectLiteralProp({ key: 'test', value: 10 })] })
     * // would generate
     * { test: 10 }
     * ```
     */
    ObjectLiteralProp: ({ key, value, multiline, jsDoc, }: {
        key: string;
        value: LiteralValue;
        multiline?: boolean | undefined;
        jsDoc?: string | undefined;
    }) => ts.PropertyAssignment;
    /**
     * A helper to create different literals.
     *
     * ```typescript
     * Node.Literal({ value: 'test' })
     * // would generate
     * 'test'
     * ```
     * ```typescript
     * Node.Literal({ value: true })
     * // would generate
     * true
     * ```
     * ```typescript
     * Node.Literal({ value: 10 })
     * // would generate
     * 10
     * ```
     * ```typescript
     * Node.Literal({ value: { key: 'test' } })
     * // would generate
     * { key: 'test' }
     * ```
     */
    Literal: ({ value, multiline, }: {
        value: LiteralValue;
        multiline?: boolean | undefined;
    }) => ts.Expression | ts.ObjectLiteralExpression | ts.StringLiteral | ts.BooleanLiteral | ts.NullLiteral | ts.NumericLiteral | ts.PrimaryExpression;
    /**
     * Enum member
     * ```typescript
     * Node.Enum({ name: 'Animals' members: [Node.EnumMember({ name: 'Cat' }), Node.EnumMember({ name: 'Dog' })] })
     * // would generate
     * enum Animals { Cat, Dog }
     * ```
     */
    EnumMember: ({ name, value }: {
        name: string | ts.Identifier;
        value?: string | number | undefined;
    }) => ts.EnumMember;
    /**
     * Enum
     * ```typescript
     * Node.Enum({ name: 'Animals' members: [Node.EnumMember({ name: 'Cat' }), Node.EnumMember({ name: 'Dog' })] })
     * // would generate
     * enum Animals { Cat, Dog }
     * ```
     */
    Enum: ({ name, members, isExport, isDefault, jsDoc, }: {
        name: string | ts.Identifier;
        members: ts.EnumMember[];
        isExport?: boolean | undefined;
        isDefault?: boolean | undefined;
        jsDoc?: string | undefined;
    }) => ts.EnumDeclaration;
    /**
     * A const statement
     * ```typescript
     * Node.Const({ name: 'n', value: '10' })
     * // would generate
     * const n = 10;
     * ```
     * ```typescript
     * Node.Const({ name: 'o', value: { test: 10 } })
     * // would generate
     * const o = { test: 10 };
     * ```
     */
    Const: ({ name, type, value, isExport, isDefault, multiline, jsDoc, }: {
        name: string | ts.Identifier;
        type?: ts.TypeNode | undefined;
        multiline?: boolean | undefined;
        value?: LiteralValue | ts.ArrowFunction | undefined;
        isExport?: boolean | undefined;
        isDefault?: boolean | undefined;
        jsDoc?: string | undefined;
    }) => ts.VariableStatement;
    NamespaceBlock: ({ name, block, isExport, isDefault, jsDoc, }: {
        name: string;
        block: ts.Statement[];
        isExport?: boolean | undefined;
        isDefault?: boolean | undefined;
        jsDoc?: string | undefined;
    }) => ts.ModuleDeclaration;
};