import { ConditionalValue, ConditionAnd, ConditionEquals, ConditionIf, ConditionNot, ConditionOr, Value } from '../Value';
import { CloudFormationTemplate } from './cloudformation-template';
import { Outputs } from './outputs';
import { Parameter, Params } from './parameter';
import { BuilderWith, BuiltIns } from './template-creator';
export declare function keepCase<T>(item: T): T;
export declare function and(a: ConditionalValue, b: ConditionalValue): ConditionAnd;
export declare function or(a: ConditionalValue, b: ConditionalValue): ConditionOr;
export declare function equals(a: ConditionalValue, b: ConditionalValue): ConditionEquals;
export declare function not(a: ConditionalValue): ConditionNot;
export declare function ifCondition(predicate: ConditionalValue, whenTrue: ConditionalValue, whenFalse: ConditionalValue): ConditionIf;
export type ConditionalFunctions = {
    and: typeof and;
    or: typeof or;
    equals: typeof equals;
    not: typeof not;
    if: typeof ifCondition;
};
export declare class TemplateBuilder<AWS, P extends {
    [param: string]: Parameter;
}, C extends Record<string, never> = {}> {
    private readonly aws;
    outputFileName: string;
    parameterFileName: string;
    private parameters;
    private outputDir;
    private conditions;
    private _templateTransform;
    private transforms;
    constructor(aws: AWS, outputFileName: string, parameterFileName?: string);
    withCondition<S extends string>(name: S, predicate: (args: {
        compare: ConditionalFunctions;
        params: Params<P>;
        condition: (name: keyof C) => Value<boolean>;
    }) => ConditionalValue): TemplateBuilder<AWS, P, C & {
        [k in S]: never;
    }>;
    withTransform(transform: string): TemplateBuilder<AWS, P, C>;
    params<P2 extends {
        [param: string]: Parameter;
    }>(params: P2): TemplateBuilder<AWS, P & P2, C>;
    envParams<P2 extends {
        [params: string]: string;
    }>(params: P2): TemplateBuilder<AWS, P & {
        [K in keyof P2]: {
            type: 'Future';
            environmentName: P2[K];
        };
    }, C>;
    outputTo(directory: string): this;
    transformTemplate(_templateTransform?: (template: CloudFormationTemplate) => string): this;
    private pathTo;
    build(builder: BuilderWith<AWS, P, keyof C & string>): {
        template: CloudFormationTemplate;
        outputs?: Outputs;
    };
    static create<AWS, C extends Record<string, never> = {}>(aws: AWS & BuiltIns, outputFileName?: string, parametersFileName?: string): TemplateBuilder<AWS, {}, C>;
}
