/**
 * Parameter validators for Tinybird pipe queries
 * Similar to the column type validators but for query parameters
 */
declare const PARAM_BRAND: unique symbol;
/**
 * Base interface for parameter validators
 */
export interface ParamValidator<TType, TTinybirdType extends string = string, TRequired extends boolean = true> {
    readonly [PARAM_BRAND]: true;
    /** The inferred TypeScript type */
    readonly _type: TType;
    /** The Tinybird type string for the parameter */
    readonly _tinybirdType: TTinybirdType;
    /** Whether this parameter is required */
    readonly _required: TRequired;
    /** Default value if optional */
    readonly _default?: TType;
    /** Description for documentation */
    readonly _description?: string;
    /** Whether required/optional was explicitly set by a modifier */
    readonly _requiredModifier?: "required" | "optional";
    /** Make this parameter optional with an optional default value */
    optional<TDefault extends TType | undefined = undefined>(defaultValue?: TDefault): ParamValidator<TDefault extends undefined ? TType | undefined : TType, TTinybirdType, false>;
    /** Make this parameter required (default) */
    required(): ParamValidator<TType, TTinybirdType, true>;
    /** Add a description for this parameter */
    describe(description: string): ParamValidator<TType, TTinybirdType, TRequired>;
}
/**
 * Parameter validators for Tinybird pipe queries
 *
 * @example
 * ```ts
 * import { p } from '@tinybirdco/sdk';
 *
 * const params = {
 *   user_id: p.string(),
 *   limit: p.int32().optional(10),
 *   start_date: p.dateTime().describe('Start of date range'),
 * };
 * ```
 */
export declare const p: {
    /** String parameter */
    readonly string: () => ParamValidator<string, "String", true>;
    /** UUID parameter */
    readonly uuid: () => ParamValidator<string, "UUID", true>;
    /** Int8 parameter */
    readonly int8: () => ParamValidator<number, "Int8", true>;
    /** Int16 parameter */
    readonly int16: () => ParamValidator<number, "Int16", true>;
    /** Int32 parameter */
    readonly int32: () => ParamValidator<number, "Int32", true>;
    /** Int64 parameter */
    readonly int64: () => ParamValidator<number, "Int64", true>;
    /** UInt8 parameter */
    readonly uint8: () => ParamValidator<number, "UInt8", true>;
    /** UInt16 parameter */
    readonly uint16: () => ParamValidator<number, "UInt16", true>;
    /** UInt32 parameter */
    readonly uint32: () => ParamValidator<number, "UInt32", true>;
    /** UInt64 parameter */
    readonly uint64: () => ParamValidator<number, "UInt64", true>;
    /** Float32 parameter */
    readonly float32: () => ParamValidator<number, "Float32", true>;
    /** Float64 parameter */
    readonly float64: () => ParamValidator<number, "Float64", true>;
    /** Boolean parameter */
    readonly boolean: () => ParamValidator<boolean, "Boolean", true>;
    /** Date parameter (YYYY-MM-DD format, e.g. 2024-01-15) */
    readonly date: () => ParamValidator<string, "Date", true>;
    /** DateTime parameter (YYYY-MM-DD HH:MM:SS format, e.g. 2024-01-15 10:30:00) */
    readonly dateTime: () => ParamValidator<string, "DateTime", true>;
    /** DateTime64 parameter (YYYY-MM-DD HH:MM:SS[.fraction] format, e.g. 2024-01-15 10:30:00.123) */
    readonly dateTime64: () => ParamValidator<string, "DateTime64", true>;
    /**
     * Array parameter - values can be passed as comma-separated or repeated params
     * @param _element - The type of array elements (used for type inference)
     * @param _separator - Optional custom separator (default: comma)
     */
    readonly array: <TElement extends ParamValidator<unknown, string, boolean>>(_element: TElement, _separator?: string) => ParamValidator<TElement["_type"][], "Array", true>;
    /**
     * Column reference parameter - allows dynamic column selection
     * Use with caution as it can affect query safety
     */
    readonly column: () => ParamValidator<string, "column", true>;
    /**
     * JSON parameter - for passing complex structured data
     */
    readonly json: <TShape = unknown>() => ParamValidator<TShape, "JSON", true>;
};
/** Type alias for any parameter validator */
export type AnyParamValidator = ParamValidator<unknown, string, boolean>;
/** Extract the TypeScript type from a parameter validator */
export type InferParamType<T extends AnyParamValidator> = T["_required"] extends true ? T["_type"] : T["_type"] | undefined;
/** Check if a value is a parameter validator */
export declare function isParamValidator(value: unknown): value is AnyParamValidator;
/** Get the Tinybird type string from a parameter validator */
export declare function getParamTinybirdType(validator: AnyParamValidator): string;
/** Check if a parameter is required */
export declare function isParamRequired(validator: AnyParamValidator): boolean;
/** Get the default value of a parameter */
export declare function getParamDefault<T>(validator: ParamValidator<T, string, boolean>): T | undefined;
/** Get the description of a parameter */
export declare function getParamDescription(validator: AnyParamValidator): string | undefined;
/** Check whether required/optional was explicitly set by a modifier */
export declare function getParamRequiredModifier(validator: AnyParamValidator): "required" | "optional" | undefined;
export {};
//# sourceMappingURL=params.d.ts.map