/**
 * OpenQASM 2.0 Abstract Syntax Tree Node Definitions
 *
 * This module defines the AST node classes for OpenQASM 2.0, which provides
 * a simpler and more limited set of constructs compared to OpenQASM 3.0.
 *
 * OpenQASM 2.0 focuses on:
 * - Basic quantum register (`qreg`) and classical register (`creg`) declarations
 * - Gate definitions and applications
 * - Measurement operations
 * - Simple conditional statements
 * - Basic arithmetic expressions
 *
 * Key limitations compared to 3.0:
 * - No advanced classical types (only registers)
 * - No control flow structures (loops, complex conditionals)
 * - No function definitions or subroutines
 * - Limited expression capabilities
 *
 * @module
 *
 * @example Basic OpenQASM 2.0 constructs
 * ```typescript
 * // Quantum register: qreg q[2];
 * new QReg('q', 2)
 *
 * // Gate application: h q[0];
 * new ApplyGate('h', [['q', 0]], [])
 *
 * // Measurement: measure q[0] -> c[0];
 * new Measure('q', 'c', 0, 0)
 * ```
 */
import { OpenQASMVersion } from "../version";
/** Base class representing a basic AST node. */
declare class AstNode {
}
/** Class representing the version statement. */
declare class Version extends AstNode {
    version: OpenQASMVersion;
    constructor(version: OpenQASMVersion);
}
/** Class representing an include statement. */
declare class Include extends AstNode {
    filename: string;
    constructor(filename: string);
}
/** Class representing a qubit register. */
declare class QReg extends AstNode {
    size: number;
    id: string;
    constructor(id: string, size: number);
}
/** Class representing a classical register. */
declare class CReg extends AstNode {
    size: number;
    id: string;
    constructor(id: string, size: number);
}
/** Class representing an identifier. */
declare class Id extends AstNode {
    id: string;
    constructor(id: string);
}
/** Class representing a barrier. */
declare class Barrier extends AstNode {
    index: number;
    register: string;
    constructor(register: string, index?: number);
}
/** Class representing a variable. */
declare class Variable extends AstNode {
    value: string;
    constructor(value: string);
}
/** Class representing a measurement. */
declare class Measure extends AstNode {
    src_index: number;
    src_register: string;
    dest_index: number;
    dest_register: string;
    constructor(src_register: string, dest_register: string, src_index?: number, dest_index?: number);
}
/** Class representing a gate application. */
declare class ApplyGate extends AstNode {
    name: string;
    qubits: Array<[string, number?]>;
    params: Array<AstNode>;
    constructor(name: string, qubits: Array<[string, number?]>, params: Array<AstNode>);
}
/** Class representing a gate. */
declare class Gate extends AstNode {
    name: string;
    registers: Array<string>;
    params: Array<string>;
    nodes: Array<AstNode>;
    constructor(name: string, registers: Array<string>, params: Array<string>, nodes: Array<AstNode>);
}
/** Class representing an opaque gate declaration (only available in OpenQASM 2.x versions) */
declare class Opaque extends AstNode {
    name: string;
    qubits: Array<[string, number?]>;
    params: Array<string>;
    constructor(name: string, qubits: Array<[string, number?]>, params?: Array<string>);
}
/** Class representing conditional. */
declare class If extends AstNode {
    register: string;
    param: number;
    gate: AstNode;
    constructor(register: string, param: number, gate: AstNode);
}
/** Class representing minus. */
declare class Minus extends AstNode {
}
/** Class representing plus. */
declare class Plus extends AstNode {
}
/** Class representing times. */
declare class Times extends AstNode {
}
/** Class representing power. */
declare class Power extends AstNode {
}
/** Class representing division. */
declare class Divide extends AstNode {
}
/** Class representing pi. */
declare class Pi extends AstNode {
}
/** Class representing the square root. */
declare class Sqrt extends AstNode {
}
/** Class representing natural logarithm. */
declare class Ln extends AstNode {
}
/** Class representing exponentiation. */
declare class Exp extends AstNode {
}
/** Class representing tagnent. */
declare class Tan extends AstNode {
}
/** Class representing cosine. */
declare class Cos extends AstNode {
}
/** Class representing sine. */
declare class Sin extends AstNode {
}
/** Class representing an integer. */
declare class NNInteger extends AstNode {
    value: number;
    constructor(value: number);
}
/** Class representing a real. */
declare class Real extends AstNode {
    value: number;
    constructor(value: number);
}
export { AstNode, Version, Include, QReg, CReg, Barrier, Measure, ApplyGate, Gate, Opaque, If, Id, Divide, Plus, Minus, Times, Power, Sin, Cos, Tan, Exp, Ln, Sqrt, Pi, NNInteger, Real, Variable, };