qasm-ts 2.1.3 → 2.1.4

package/dist/qasm3/token.d.ts

@@ -0,0 +1,197 @@
+/**
+ * OpenQASM 3.0 Token Definitions and Utilities
+ *
+ * This module defines all the token types used in OpenQASM 3.0 syntax, which
+ * significantly extends OpenQASM 2.0 with modern programming language features.
+ *
+ * Major additions in OpenQASM 3.0:
+ * - **Classical types**: int, uint, float, bool, bit, complex
+ * - **Control flow**: if/else, for/while loops, switch/case
+ * - **Functions**: def, return, extern declarations
+ * - **Advanced features**: arrays, timing (delay, durationof), calibration
+ * - **Quantum extensions**: qubit declarations, gate modifiers, hardware qubits
+ *
+ * @module
+ *
+ * @example OpenQASM 3.0 advanced tokens
+ * ```typescript
+ * import { lookup, Token } from './qasm3/token';
+ *
+ * console.log(lookup('qubit'));    // Token.Qubit
+ * console.log(lookup('if'));       // Token.If
+ * console.log(lookup('def'));      // Token.Def
+ * console.log(lookup('complex'));  // Token.Complex
+ * ```
+ */
+/**
+ * Enumeration of all OpenQASM 3.0 token types.
+ *
+ * Each token represents a specific syntactic element in OpenQASM 3.0 code.
+ * The enum values correspond to different categories:
+ * - Literals: NNInteger, Real, String, BoolLiteral
+ * - Identifiers: Id
+ * - Keywords: Qubit, Gate, Measure, If, For, While, etc.
+ * - Operators: ArithmeticOp, BinaryOp, UnaryOp
+ * - Punctuation: Semicolon, Comma, LParen, RParen, etc.
+ * - Special: OpenQASM, Include, EndOfFile, Illegal
+ */
+declare enum Token {
+    Illegal = 0,
+    EndOfFile = 1,
+    Real = 2,
+    NNInteger = 3,
+    Integer = 4,
+    Id = 5,
+    OpenQASM = 6,
+    Include = 7,
+    Semicolon = 8,
+    Colon = 9,
+    Comma = 10,
+    LParen = 11,
+    LSParen = 12,
+    LCParen = 13,
+    RParen = 14,
+    RSParen = 15,
+    RCParen = 16,
+    EqualsAssmt = 17,
+    Arrow = 18,
+    QReg = 19,
+    Qubit = 20,
+    CReg = 21,
+    Bit = 22,
+    Barrier = 23,
+    Gate = 24,
+    Measure = 25,
+    Reset = 26,
+    String = 27,
+    Opaque = 28,
+    DefcalGrammar = 29,
+    Float = 30,
+    Bool = 31,
+    Int = 32,
+    UInt = 33,
+    Pi = 34,
+    Euler = 35,
+    Tau = 36,
+    BinaryLiteral = 37,
+    OctalLiteral = 38,
+    HexLiteral = 39,
+    ArithmeticOp = 40,
+    CompoundArithmeticOp = 41,
+    BoolLiteral = 42,
+    Duration = 43,
+    UnaryOp = 44,
+    BinaryOp = 45,
+    Let = 46,
+    QuantumModifier = 47,
+    Delay = 48,
+    Return = 49,
+    Def = 50,
+    For = 51,
+    In = 52,
+    While = 53,
+    Break = 54,
+    Continue = 55,
+    Input = 56,
+    Output = 57,
+    Switch = 58,
+    Case = 59,
+    Default = 60,
+    Defcal = 61,
+    Const = 62,
+    If = 63,
+    Else = 64,
+    End = 65,
+    Arccos = 66,
+    Arcsin = 67,
+    Arctan = 68,
+    Ceiling = 69,
+    Cos = 70,
+    Exp = 71,
+    Floor = 72,
+    Log = 73,
+    Mod = 74,
+    Popcount = 75,
+    Pow = 76,
+    Rotl = 77,
+    Rotr = 78,
+    Sin = 79,
+    Sqrt = 80,
+    Tan = 81,
+    Angle = 82,
+    Ctrl = 83,
+    NegCtrl = 84,
+    Inv = 85,
+    PowM = 86,
+    At = 87,
+    Complex = 88,
+    Dollar = 89,
+    Array = 90,
+    DurationOf = 91,
+    Stretch = 92,
+    Box = 93,
+    ReadOnly = 94,
+    Mutable = 95,
+    Dim = 96,
+    ScientificNotation = 97,
+    SizeOf = 98,
+    Extern = 99,
+    CompoundBinaryOp = 100
+}
+/**
+ * Returns the token type that corresponds to a given string.
+ *
+ * This function is used by the lexer to classify identifiers and keywords.
+ * If the string is a reserved keyword, it returns the appropriate token type.
+ * Otherwise, it returns Token.Id to indicate a user-defined identifier.
+ *
+ * @param ident - The string to look up
+ * @returns The corresponding token type
+ *
+ * @example Keyword lookup
+ * ```typescript
+ * lookup('qubit');     // Returns Token.Qubit
+ * lookup('measure');   // Returns Token.Measure
+ * lookup('myVar');     // Returns Token.Id
+ * lookup('π');         // Returns Token.Pi
+ * ```
+ */
+declare function lookup(ident: string): Token;
+/**
+ * Returns the string representation of a token type.
+ *
+ * This is useful for debugging and error reporting, allowing you to
+ * convert token enum values back to their string representations.
+ *
+ * @param token - The token type to convert
+ * @returns The string representation of the token, or undefined if not found
+ *
+ * @example Token to string conversion
+ * ```typescript
+ * inverseLookup(Token.Qubit);   // Returns 'qubit'
+ * inverseLookup(Token.If);      // Returns 'if'
+ * inverseLookup(Token.Pi);      // Returns 'pi'
+ * ```
+ */
+declare function inverseLookup(token: Token): string;
+/**
+ * Determines whether a token can be used as a parameter in expressions.
+ *
+ * This function helps the parser validate parameter lists by checking if
+ * a token type is allowed in parameter contexts. Parameters can include
+ * identifiers, numbers, and other value-bearing tokens, but not structural
+ * tokens like semicolons or braces.
+ *
+ * @param token - The token type to check
+ * @returns true if the token CANNOT be used as a parameter, false otherwise
+ *
+ * @example Parameter validation
+ * ```typescript
+ * notParam(Token.Id);         // false - identifiers can be parameters
+ * notParam(Token.NNInteger);  // false - numbers can be parameters
+ * notParam(Token.Semicolon);  // true - semicolons cannot be parameters
+ * notParam(Token.LParen);     // true - parentheses cannot be parameters
+ * ```
+ */
+declare function notParam(token: Token): boolean;
+export { Token, notParam, lookup, inverseLookup };

package/dist/qasm3/token.js

@@ -0,0 +1,420 @@
+/**
+ * OpenQASM 3.0 Token Definitions and Utilities
+ *
+ * This module defines all the token types used in OpenQASM 3.0 syntax, which
+ * significantly extends OpenQASM 2.0 with modern programming language features.
+ *
+ * Major additions in OpenQASM 3.0:
+ * - **Classical types**: int, uint, float, bool, bit, complex
+ * - **Control flow**: if/else, for/while loops, switch/case
+ * - **Functions**: def, return, extern declarations
+ * - **Advanced features**: arrays, timing (delay, durationof), calibration
+ * - **Quantum extensions**: qubit declarations, gate modifiers, hardware qubits
+ *
+ * @module
+ *
+ * @example OpenQASM 3.0 advanced tokens
+ * ```typescript
+ * import { lookup, Token } from './qasm3/token';
+ *
+ * console.log(lookup('qubit'));    // Token.Qubit
+ * console.log(lookup('if'));       // Token.If
+ * console.log(lookup('def'));      // Token.Def
+ * console.log(lookup('complex'));  // Token.Complex
+ * ```
+ */
+/**
+ * Enumeration of all OpenQASM 3.0 token types.
+ *
+ * Each token represents a specific syntactic element in OpenQASM 3.0 code.
+ * The enum values correspond to different categories:
+ * - Literals: NNInteger, Real, String, BoolLiteral
+ * - Identifiers: Id
+ * - Keywords: Qubit, Gate, Measure, If, For, While, etc.
+ * - Operators: ArithmeticOp, BinaryOp, UnaryOp
+ * - Punctuation: Semicolon, Comma, LParen, RParen, etc.
+ * - Special: OpenQASM, Include, EndOfFile, Illegal
+ */
+var Token;
+(function (Token) {
+    // 0; invalid or unrecognized token
+    Token[Token["Illegal"] = 0] = "Illegal";
+    // 1; end of file character
+    Token[Token["EndOfFile"] = 1] = "EndOfFile";
+    // 2; real number (floating point)
+    Token[Token["Real"] = 2] = "Real";
+    // 3; non-negative integer
+    Token[Token["NNInteger"] = 3] = "NNInteger";
+    // 4; integer that supports underscores and negatives
+    Token[Token["Integer"] = 4] = "Integer";
+    // 5; identifier (variables names, function names, etc.)
+    Token[Token["Id"] = 5] = "Id";
+    // 6; OPENQASM version declaration
+    Token[Token["OpenQASM"] = 6] = "OpenQASM";
+    // 7; include statement
+    Token[Token["Include"] = 7] = "Include";
+    // 8; semicolon to terminate statements
+    Token[Token["Semicolon"] = 8] = "Semicolon";
+    // 9; colon
+    Token[Token["Colon"] = 9] = "Colon";
+    // 10; comma
+    Token[Token["Comma"] = 10] = "Comma";
+    // 11; left paren (
+    Token[Token["LParen"] = 11] = "LParen";
+    // 12; left square bracket [
+    Token[Token["LSParen"] = 12] = "LSParen";
+    // 13; left curly brakcet {
+    Token[Token["LCParen"] = 13] = "LCParen";
+    // 14; right paren )
+    Token[Token["RParen"] = 14] = "RParen";
+    // 15; right square paren ]
+    Token[Token["RSParen"] = 15] = "RSParen";
+    // 16; right curly bracket }
+    Token[Token["RCParen"] = 16] = "RCParen";
+    // 17; assignment operator (=)
+    Token[Token["EqualsAssmt"] = 17] = "EqualsAssmt";
+    // 18; arrow (->) used in measurement operations
+    Token[Token["Arrow"] = 18] = "Arrow";
+    // 19; quantum register declaration
+    Token[Token["QReg"] = 19] = "QReg";
+    // 20; quantum register declaration (functionally equivalent to QReg but for OpenQASM version 3)
+    Token[Token["Qubit"] = 20] = "Qubit";
+    // 21; classical register declaration
+    Token[Token["CReg"] = 21] = "CReg";
+    // 22; classical register declaration (functionally equivalent to Creg but for OpenQASM version 3)
+    Token[Token["Bit"] = 22] = "Bit";
+    // 23; barrier operation
+    Token[Token["Barrier"] = 23] = "Barrier";
+    // 24; gate declaration or application
+    Token[Token["Gate"] = 24] = "Gate";
+    // 25; measurement operation
+    Token[Token["Measure"] = 25] = "Measure";
+    // 26; qubit reset operation
+    Token[Token["Reset"] = 26] = "Reset";
+    // 27; string literal
+    Token[Token["String"] = 27] = "String";
+    // 28; opaque keyword
+    Token[Token["Opaque"] = 28] = "Opaque";
+    // 29; defcalgrammar keyword
+    Token[Token["DefcalGrammar"] = 29] = "DefcalGrammar";
+    // 30; float type keyword
+    Token[Token["Float"] = 30] = "Float";
+    // 31; bool type keyword,
+    Token[Token["Bool"] = 31] = "Bool";
+    // 32; int type keyword
+    Token[Token["Int"] = 32] = "Int";
+    // 33; uint type keyword
+    Token[Token["UInt"] = 33] = "UInt";
+    // 34; mathematical constant pi
+    Token[Token["Pi"] = 34] = "Pi";
+    // 35; euler constant
+    Token[Token["Euler"] = 35] = "Euler";
+    // 36; tau constant
+    Token[Token["Tau"] = 36] = "Tau";
+    // 37; binary literal
+    Token[Token["BinaryLiteral"] = 37] = "BinaryLiteral";
+    // 38; octal literal
+    Token[Token["OctalLiteral"] = 38] = "OctalLiteral";
+    // 39; hex literal
+    Token[Token["HexLiteral"] = 39] = "HexLiteral";
+    // 40; arithmetic operators
+    Token[Token["ArithmeticOp"] = 40] = "ArithmeticOp";
+    // 41; compound arithmetic operators
+    Token[Token["CompoundArithmeticOp"] = 41] = "CompoundArithmeticOp";
+    // 42; boolean literal value
+    Token[Token["BoolLiteral"] = 42] = "BoolLiteral";
+    // 43; duration keyword
+    Token[Token["Duration"] = 43] = "Duration";
+    // 44; unary operator
+    Token[Token["UnaryOp"] = 44] = "UnaryOp";
+    // 45; binary operator
+    Token[Token["BinaryOp"] = 45] = "BinaryOp";
+    // 46; let keyword for aliasing
+    Token[Token["Let"] = 46] = "Let";
+    // 47; quantum gate modifier
+    Token[Token["QuantumModifier"] = 47] = "QuantumModifier";
+    // 48; delay keyword
+    Token[Token["Delay"] = 48] = "Delay";
+    // 49; return keyword
+    Token[Token["Return"] = 49] = "Return";
+    // 50; def keyword for subroutines
+    Token[Token["Def"] = 50] = "Def";
+    // 51; for loop keyword
+    Token[Token["For"] = 51] = "For";
+    // 52; in keyword
+    Token[Token["In"] = 52] = "In";
+    // 53; while loop keyword
+    Token[Token["While"] = 53] = "While";
+    // 54; break keyword
+    Token[Token["Break"] = 54] = "Break";
+    // 55; continue keyword
+    Token[Token["Continue"] = 55] = "Continue";
+    // 56; input keyword
+    Token[Token["Input"] = 56] = "Input";
+    // 57; output keyword
+    Token[Token["Output"] = 57] = "Output";
+    // 58; switch statement keyword
+    Token[Token["Switch"] = 58] = "Switch";
+    // 59; switch case keyword
+    Token[Token["Case"] = 59] = "Case";
+    // 60; switch default keyword
+    Token[Token["Default"] = 60] = "Default";
+    // 61; defcal keyword
+    Token[Token["Defcal"] = 61] = "Defcal";
+    // 62; constant keywork
+    Token[Token["Const"] = 62] = "Const";
+    // 63; if statement conditional
+    Token[Token["If"] = 63] = "If";
+    // 64; else keyword
+    Token[Token["Else"] = 64] = "Else";
+    // 65; end keyword
+    Token[Token["End"] = 65] = "End";
+    // 66; inverse cosine
+    Token[Token["Arccos"] = 66] = "Arccos";
+    // 67; inverse sine
+    Token[Token["Arcsin"] = 67] = "Arcsin";
+    // 68; inverse tangent
+    Token[Token["Arctan"] = 68] = "Arctan";
+    // 69; ceiling function
+    Token[Token["Ceiling"] = 69] = "Ceiling";
+    // 70; cosine function
+    Token[Token["Cos"] = 70] = "Cos";
+    // 71; exp keyword
+    Token[Token["Exp"] = 71] = "Exp";
+    // 72; floor function
+    Token[Token["Floor"] = 72] = "Floor";
+    // 73; logarithm base e
+    Token[Token["Log"] = 73] = "Log";
+    // 74; modulus
+    Token[Token["Mod"] = 74] = "Mod";
+    // 75; popcount function
+    Token[Token["Popcount"] = 75] = "Popcount";
+    // 76; power function
+    Token[Token["Pow"] = 76] = "Pow";
+    // 77; rotate bits left function
+    Token[Token["Rotl"] = 77] = "Rotl";
+    // 78; rotate bits right function
+    Token[Token["Rotr"] = 78] = "Rotr";
+    // 79; sine
+    Token[Token["Sin"] = 79] = "Sin";
+    // 80; sqaure root
+    Token[Token["Sqrt"] = 80] = "Sqrt";
+    // 81; tangent
+    Token[Token["Tan"] = 81] = "Tan";
+    // 82; angle type
+    Token[Token["Angle"] = 82] = "Angle";
+    // 83; ctrl gate modifier
+    Token[Token["Ctrl"] = 83] = "Ctrl";
+    // 84; negctrl gate modifier
+    Token[Token["NegCtrl"] = 84] = "NegCtrl";
+    // 85; inv gate modifier
+    Token[Token["Inv"] = 85] = "Inv";
+    // 86; pow gate modifier
+    Token[Token["PowM"] = 86] = "PowM";
+    // 87; @ symbol
+    Token[Token["At"] = 87] = "At";
+    // 88; complex number keyword
+    Token[Token["Complex"] = 88] = "Complex";
+    // 89; $ symbol
+    Token[Token["Dollar"] = 89] = "Dollar";
+    // 90; array keyword
+    Token[Token["Array"] = 90] = "Array";
+    // 91; durationof function keyword
+    Token[Token["DurationOf"] = 91] = "DurationOf";
+    // 92; stretch type keyword
+    Token[Token["Stretch"] = 92] = "Stretch";
+    // 93; box keyword
+    Token[Token["Box"] = 93] = "Box";
+    // 94; readonly keyword
+    Token[Token["ReadOnly"] = 94] = "ReadOnly";
+    // 95; mutable keyword
+    Token[Token["Mutable"] = 95] = "Mutable";
+    // 96; #dim array dimensions
+    Token[Token["Dim"] = 96] = "Dim";
+    // 97; scientific notation literal
+    Token[Token["ScientificNotation"] = 97] = "ScientificNotation";
+    // 98; sizeof function
+    Token[Token["SizeOf"] = 98] = "SizeOf";
+    // 99; extern keyword
+    Token[Token["Extern"] = 99] = "Extern";
+    // 100; compound binary operators
+    Token[Token["CompoundBinaryOp"] = 100] = "CompoundBinaryOp";
+})(Token || (Token = {}));
+/**
+ * Mapping of string keywords to their corresponding token types.
+ *
+ * This lookup table enables the lexer to quickly determine if a string
+ * represents a reserved keyword or should be treated as an identifier.
+ *
+ * @internal
+ */
+const lookupMap = {
+    pi: Token.Pi,
+    π: Token.Pi,
+    qreg: Token.QReg,
+    qubit: Token.Qubit,
+    creg: Token.CReg,
+    bit: Token.Bit,
+    barrier: Token.Barrier,
+    gate: Token.Gate,
+    measure: Token.Measure,
+    reset: Token.Reset,
+    include: Token.Include,
+    if: Token.If,
+    opaque: Token.Opaque,
+    defcalgrammar: Token.DefcalGrammar,
+    float: Token.Float,
+    bool: Token.Bool,
+    true: Token.BoolLiteral,
+    false: Token.BoolLiteral,
+    int: Token.Int,
+    uint: Token.UInt,
+    euler: Token.Euler,
+    ℇ: Token.Euler,
+    tau: Token.Tau,
+    τ: Token.Tau,
+    duration: Token.Duration,
+    let: Token.Let,
+    delay: Token.Delay,
+    return: Token.Return,
+    def: Token.Def,
+    for: Token.For,
+    in: Token.In,
+    while: Token.While,
+    break: Token.Break,
+    continue: Token.Continue,
+    input: Token.Input,
+    output: Token.Output,
+    switch: Token.Switch,
+    case: Token.Case,
+    default: Token.Default,
+    defcal: Token.Defcal,
+    const: Token.Const,
+    else: Token.Else,
+    end: Token.End,
+    "!": Token.UnaryOp,
+    "~": Token.UnaryOp,
+    "**": Token.ArithmeticOp,
+    "*": Token.ArithmeticOp,
+    "/": Token.ArithmeticOp,
+    "%": Token.ArithmeticOp,
+    "+": Token.ArithmeticOp,
+    "++": Token.ArithmeticOp,
+    "&": Token.BinaryOp,
+    "|": Token.BinaryOp,
+    "^": Token.BinaryOp,
+    "&&": Token.BinaryOp,
+    "||": Token.BinaryOp,
+    "<": Token.BinaryOp,
+    "<=": Token.BinaryOp,
+    ">": Token.BinaryOp,
+    ">=": Token.BinaryOp,
+    "==": Token.BinaryOp,
+    "!=": Token.BinaryOp,
+    "<<": Token.BinaryOp,
+    ">>": Token.BinaryOp,
+    "**=": Token.CompoundArithmeticOp,
+    "/=": Token.CompoundArithmeticOp,
+    "%=": Token.CompoundArithmeticOp,
+    "+=": Token.CompoundArithmeticOp,
+    "-=": Token.CompoundArithmeticOp,
+    "*=": Token.CompoundArithmeticOp,
+    "^=": Token.CompoundArithmeticOp,
+    arccos: Token.Arccos,
+    arcsin: Token.Arcsin,
+    arctan: Token.Arctan,
+    ceiling: Token.Ceiling,
+    cos: Token.Cos,
+    exp: Token.Exp,
+    floor: Token.Floor,
+    log: Token.Log,
+    mod: Token.Mod,
+    popcount: Token.Popcount,
+    pow: Token.Pow,
+    rotl: Token.Rotl,
+    rotr: Token.Rotr,
+    sin: Token.Sin,
+    sqrt: Token.Sqrt,
+    tan: Token.Tan,
+    angle: Token.Angle,
+    "@": Token.At,
+    complex: Token.Complex,
+    $: Token.Dollar,
+    array: Token.Array,
+    durationof: Token.DurationOf,
+    stretch: Token.Stretch,
+    box: Token.Box,
+    readonly: Token.ReadOnly,
+    mutable: Token.Mutable,
+    sizeof: Token.SizeOf,
+    extern: Token.Extern,
+};
+/**
+ * Returns the token type that corresponds to a given string.
+ *
+ * This function is used by the lexer to classify identifiers and keywords.
+ * If the string is a reserved keyword, it returns the appropriate token type.
+ * Otherwise, it returns Token.Id to indicate a user-defined identifier.
+ *
+ * @param ident - The string to look up
+ * @returns The corresponding token type
+ *
+ * @example Keyword lookup
+ * ```typescript
+ * lookup('qubit');     // Returns Token.Qubit
+ * lookup('measure');   // Returns Token.Measure
+ * lookup('myVar');     // Returns Token.Id
+ * lookup('π');         // Returns Token.Pi
+ * ```
+ */
+function lookup(ident) {
+    return ident in lookupMap ? lookupMap[ident] : Token.Id;
+}
+/**
+ * Returns the string representation of a token type.
+ *
+ * This is useful for debugging and error reporting, allowing you to
+ * convert token enum values back to their string representations.
+ *
+ * @param token - The token type to convert
+ * @returns The string representation of the token, or undefined if not found
+ *
+ * @example Token to string conversion
+ * ```typescript
+ * inverseLookup(Token.Qubit);   // Returns 'qubit'
+ * inverseLookup(Token.If);      // Returns 'if'
+ * inverseLookup(Token.Pi);      // Returns 'pi'
+ * ```
+ */
+function inverseLookup(token) {
+    return Object.keys(lookupMap).find((ident) => lookupMap[ident] == token);
+}
+/**
+ * Determines whether a token can be used as a parameter in expressions.
+ *
+ * This function helps the parser validate parameter lists by checking if
+ * a token type is allowed in parameter contexts. Parameters can include
+ * identifiers, numbers, and other value-bearing tokens, but not structural
+ * tokens like semicolons or braces.
+ *
+ * @param token - The token type to check
+ * @returns true if the token CANNOT be used as a parameter, false otherwise
+ *
+ * @example Parameter validation
+ * ```typescript
+ * notParam(Token.Id);         // false - identifiers can be parameters
+ * notParam(Token.NNInteger);  // false - numbers can be parameters
+ * notParam(Token.Semicolon);  // true - semicolons cannot be parameters
+ * notParam(Token.LParen);     // true - parentheses cannot be parameters
+ * ```
+ */
+function notParam(token) {
+    if (token == Token.NNInteger ||
+        token == Token.Real ||
+        token == Token.Id ||
+        inverseLookup(token)) {
+        return false;
+    }
+    return true;
+}
+export { Token, notParam, lookup, inverseLookup };

package/dist/version.d.ts

@@ -0,0 +1,41 @@
+/**
+ * OpenQASM version detection and management utilities
+ *
+ * Handles version detection from QASM source code and provides utilities
+ * for working with different OpenQASM versions. Supports automatic version
+ * detection from OPENQASM statements and manual version specification.
+ *
+ * @module Version Management
+ *
+ * @example Version detection
+ * ```typescript
+ * const version = new OpenQASMVersion(3, 0);
+ * console.log(version.toString()); // "3.0"
+ * console.log(version.isVersion3()); // true
+ * ```
+ */
+/** Enum representing the major OpenQASM versions. */
+declare enum OpenQASMMajorVersion {
+    Version2 = 2,
+    Version3 = 3
+}
+/** Class representing the OpenQASM version. */
+declare class OpenQASMVersion {
+    /** The major OpenQASM version. */
+    major: OpenQASMMajorVersion;
+    /** The minor OpenQASM version. */
+    minor: number;
+    /**
+     * Creates an OpenQASMVersion instance.
+     * @param major - The OpenQASM major version. (optional)
+     * @param minor - The OpenQASM minor version (optional)
+     */
+    constructor(major?: OpenQASMMajorVersion, minor?: number);
+    /** Returns the version as a formatted string. */
+    toString(): string;
+    /** Returns whether the version is 3.x */
+    isVersion3(): boolean;
+    /** Returns whether the version is 2.x */
+    isVersion2(): boolean;
+}
+export { OpenQASMMajorVersion, OpenQASMVersion };