qukit/pkg.nodejs/pkg/qukit.d.ts

[](https://www.npmjs.com/package/qukit) [](https://crates.io/crates/qukit) [](https://opensource.org/lice

/* tslint:disable */
/* eslint-disable */
/**
* @param {QBit} qbit
*/
export function hadamard(qbit: QBit): void;
/**
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_hadamard(c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_hadamard(c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {QBit} qbit
*/
export function hadamard_same_step(qbit: QBit): void;
/**
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_hadamard_same_step(c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_hadamard_same_step(c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {QBit} qbit
* @param {Bit} bit
*/
export function hadamard_same_step_classically_controlled(qbit: QBit, bit: Bit): void;
/**
* @param {QBit} qbit
* @param {Bit} bit
*/
export function hadamard_classically_controlled(qbit: QBit, bit: Bit): void;
/**
* @param {QBit} qbit
*/
export function pauli_x(qbit: QBit): void;
/**
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_pauli_x(c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_pauli_x(c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {QBit} qbit
*/
export function pauli_x_same_step(qbit: QBit): void;
/**
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_pauli_x_same_step(c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_pauli_x_same_step(c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {QBit} qbit
* @param {Bit} bit
*/
export function pauli_x_same_step_classically_controlled(qbit: QBit, bit: Bit): void;
/**
* @param {QBit} qbit
* @param {Bit} bit
*/
export function pauli_x_classically_controlled(qbit: QBit, bit: Bit): void;
/**
* @param {QBit} qbit
*/
export function pauli_y(qbit: QBit): void;
/**
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_pauli_y(c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_pauli_y(c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {QBit} qbit
*/
export function pauli_y_same_step(qbit: QBit): void;
/**
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_pauli_y_same_step(c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_pauli_y_same_step(c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {QBit} qbit
* @param {Bit} bit
*/
export function pauli_y_same_step_classically_controlled(qbit: QBit, bit: Bit): void;
/**
* @param {QBit} qbit
* @param {Bit} bit
*/
export function pauli_y_classically_controlled(qbit: QBit, bit: Bit): void;
/**
* @param {QBit} qbit
*/
export function pauli_z(qbit: QBit): void;
/**
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_pauli_z(c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_pauli_z(c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {QBit} qbit
*/
export function pauli_z_same_step(qbit: QBit): void;
/**
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_pauli_z_same_step(c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_pauli_z_same_step(c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {QBit} qbit
* @param {Bit} bit
*/
export function pauli_z_same_step_classically_controlled(qbit: QBit, bit: Bit): void;
/**
* @param {QBit} qbit
* @param {Bit} bit
*/
export function pauli_z_classically_controlled(qbit: QBit, bit: Bit): void;
/**
* @param {QBit} qbit
*/
export function phase(qbit: QBit): void;
/**
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_phase(c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_phase(c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {QBit} qbit
*/
export function phase_same_step(qbit: QBit): void;
/**
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_phase_same_step(c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_phase_same_step(c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {QBit} qbit
* @param {Bit} bit
*/
export function phase_same_step_classically_controlled(qbit: QBit, bit: Bit): void;
/**
* @param {QBit} qbit
* @param {Bit} bit
*/
export function phase_classically_controlled(qbit: QBit, bit: Bit): void;
/**
* @param {QBit} qbit
*/
export function phase_dagger(qbit: QBit): void;
/**
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_phase_dagger(c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_phase_dagger(c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {QBit} qbit
*/
export function phase_dagger_same_step(qbit: QBit): void;
/**
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_phase_dagger_same_step(c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_phase_dagger_same_step(c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {QBit} qbit
* @param {Bit} bit
*/
export function phase_dagger_same_step_classically_controlled(qbit: QBit, bit: Bit): void;
/**
* @param {QBit} qbit
* @param {Bit} bit
*/
export function phase_dagger_classically_controlled(qbit: QBit, bit: Bit): void;
/**
* @param {QBit} qbit
*/
export function phase_root(qbit: QBit): void;
/**
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_phase_root(c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_phase_root(c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {QBit} qbit
*/
export function phase_root_same_step(qbit: QBit): void;
/**
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_phase_root_same_step(c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_phase_root_same_step(c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {QBit} qbit
* @param {Bit} bit
*/
export function phase_root_same_step_classically_controlled(qbit: QBit, bit: Bit): void;
/**
* @param {QBit} qbit
* @param {Bit} bit
*/
export function phase_root_classically_controlled(qbit: QBit, bit: Bit): void;
/**
* @param {QBit} qbit
*/
export function phase_root_dagger(qbit: QBit): void;
/**
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_phase_root_dagger(c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_phase_root_dagger(c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {QBit} qbit
*/
export function phase_root_dagger_same_step(qbit: QBit): void;
/**
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_phase_root_dagger_same_step(c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_phase_root_dagger_same_step(c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {QBit} qbit
* @param {Bit} bit
*/
export function phase_root_dagger_same_step_classically_controlled(qbit: QBit, bit: Bit): void;
/**
* @param {QBit} qbit
* @param {Bit} bit
*/
export function phase_root_dagger_classically_controlled(qbit: QBit, bit: Bit): void;
/**
* @param {QBit} qbit
*/
export function pauli_x_root(qbit: QBit): void;
/**
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_pauli_x_root(c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_pauli_x_root(c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {QBit} qbit
*/
export function pauli_x_root_same_step(qbit: QBit): void;
/**
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_pauli_x_root_same_step(c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_pauli_x_root_same_step(c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {QBit} qbit
* @param {Bit} bit
*/
export function pauli_x_root_same_step_classically_controlled(qbit: QBit, bit: Bit): void;
/**
* @param {QBit} qbit
* @param {Bit} bit
*/
export function pauli_x_root_classically_controlled(qbit: QBit, bit: Bit): void;
/**
* @param {QBit} qbit_0
* @param {QBit} qbit_1
*/
export function swap(qbit_0: QBit, qbit_1: QBit): void;
/**
* @param {QBit} c_qbit
* @param {QBit} t_qbit_0
* @param {QBit} t_qbit_1
*/
export function controlled_swap(c_qbit: QBit, t_qbit_0: QBit, t_qbit_1: QBit): void;
/**
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit_0
* @param {QBit} t_qbit_1
*/
export function controlled_controlled_swap(c_qbit_0: QBit, c_qbit_1: QBit, t_qbit_0: QBit, t_qbit_1: QBit): void;
/**
* @param {QBit} qbit_0
* @param {QBit} qbit_1
*/
export function swap_same_step(qbit_0: QBit, qbit_1: QBit): void;
/**
* @param {QBit} c_qbit
* @param {QBit} t_qbit_0
* @param {QBit} t_qbit_1
*/
export function controlled_swap_same_step(c_qbit: QBit, t_qbit_0: QBit, t_qbit_1: QBit): void;
/**
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit_0
* @param {QBit} t_qbit_1
*/
export function controlled_controlled_swap_same_step(c_qbit_0: QBit, c_qbit_1: QBit, t_qbit_0: QBit, t_qbit_1: QBit): void;
/**
* @param {QBit} qbit_0
* @param {QBit} qbit_1
* @param {Bit} bit
*/
export function swap_same_step_classically_controlled(qbit_0: QBit, qbit_1: QBit, bit: Bit): void;
/**
* @param {QBit} qbit_0
* @param {QBit} qbit_1
* @param {Bit} bit
*/
export function swap_classically_controlled(qbit_0: QBit, qbit_1: QBit, bit: Bit): void;
/**
* @param {QBit} qbit_0
* @param {QBit} qbit_1
*/
export function swap_root(qbit_0: QBit, qbit_1: QBit): void;
/**
* @param {QBit} c_qbit
* @param {QBit} t_qbit_0
* @param {QBit} t_qbit_1
*/
export function controlled_swap_root(c_qbit: QBit, t_qbit_0: QBit, t_qbit_1: QBit): void;
/**
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit_0
* @param {QBit} t_qbit_1
*/
export function controlled_controlled_swap_root(c_qbit_0: QBit, c_qbit_1: QBit, t_qbit_0: QBit, t_qbit_1: QBit): void;
/**
* @param {QBit} qbit_0
* @param {QBit} qbit_1
*/
export function swap_root_same_step(qbit_0: QBit, qbit_1: QBit): void;
/**
* @param {QBit} c_qbit
* @param {QBit} t_qbit_0
* @param {QBit} t_qbit_1
*/
export function controlled_swap_root_same_step(c_qbit: QBit, t_qbit_0: QBit, t_qbit_1: QBit): void;
/**
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit_0
* @param {QBit} t_qbit_1
*/
export function controlled_controlled_swap_root_same_step(c_qbit_0: QBit, c_qbit_1: QBit, t_qbit_0: QBit, t_qbit_1: QBit): void;
/**
* @param {QBit} qbit_0
* @param {QBit} qbit_1
* @param {Bit} bit
*/
export function swap_root_same_step_classically_controlled(qbit_0: QBit, qbit_1: QBit, bit: Bit): void;
/**
* @param {QBit} qbit_0
* @param {QBit} qbit_1
* @param {Bit} bit
*/
export function swap_root_classically_controlled(qbit_0: QBit, qbit_1: QBit, bit: Bit): void;
/**
* @param {number} theta
* @param {QBit} qbit
*/
export function rotation_hadamard(theta: number, qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_rotation_hadamard(theta: number, c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_rotation_hadamard(theta: number, c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} qbit
*/
export function rotation_hadamard_same_step(theta: number, qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_rotation_hadamard_same_step(theta: number, c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_rotation_hadamard_same_step(theta: number, c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} qbit
* @param {Bit} bit
*/
export function rotation_hadamard_same_step_classically_controlled(theta: number, qbit: QBit, bit: Bit): void;
/**
* @param {number} theta
* @param {QBit} qbit
* @param {Bit} bit
*/
export function rotation_hadamard_classically_controlled(theta: number, qbit: QBit, bit: Bit): void;
/**
* @param {number} theta
* @param {QBit} qbit
*/
export function rotation_pauli_x(theta: number, qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_rotation_pauli_x(theta: number, c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_rotation_pauli_x(theta: number, c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} qbit
*/
export function rotation_pauli_x_same_step(theta: number, qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_rotation_pauli_x_same_step(theta: number, c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_rotation_pauli_x_same_step(theta: number, c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} qbit
* @param {Bit} bit
*/
export function rotation_pauli_x_same_step_classically_controlled(theta: number, qbit: QBit, bit: Bit): void;
/**
* @param {number} theta
* @param {QBit} qbit
* @param {Bit} bit
*/
export function rotation_pauli_x_classically_controlled(theta: number, qbit: QBit, bit: Bit): void;
/**
* @param {number} theta
* @param {QBit} qbit
*/
export function rotation_pauli_y(theta: number, qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_rotation_pauli_y(theta: number, c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_rotation_pauli_y(theta: number, c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} qbit
*/
export function rotation_pauli_y_same_step(theta: number, qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_rotation_pauli_y_same_step(theta: number, c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_rotation_pauli_y_same_step(theta: number, c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} qbit
* @param {Bit} bit
*/
export function rotation_pauli_y_same_step_classically_controlled(theta: number, qbit: QBit, bit: Bit): void;
/**
* @param {number} theta
* @param {QBit} qbit
* @param {Bit} bit
*/
export function rotation_pauli_y_classically_controlled(theta: number, qbit: QBit, bit: Bit): void;
/**
* @param {number} theta
* @param {QBit} qbit
*/
export function rotation_pauli_z(theta: number, qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_rotation_pauli_z(theta: number, c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_rotation_pauli_z(theta: number, c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} qbit
*/
export function rotation_pauli_z_same_step(theta: number, qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_rotation_pauli_z_same_step(theta: number, c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_rotation_pauli_z_same_step(theta: number, c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} qbit
* @param {Bit} bit
*/
export function rotation_pauli_z_same_step_classically_controlled(theta: number, qbit: QBit, bit: Bit): void;
/**
* @param {number} theta
* @param {QBit} qbit
* @param {Bit} bit
*/
export function rotation_pauli_z_classically_controlled(theta: number, qbit: QBit, bit: Bit): void;
/**
* @param {number} theta
* @param {QBit} qbit
*/
export function rotation_x(theta: number, qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_rotation_x(theta: number, c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_rotation_x(theta: number, c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} qbit
*/
export function rotation_x_same_step(theta: number, qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_rotation_x_same_step(theta: number, c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_rotation_x_same_step(theta: number, c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} qbit
* @param {Bit} bit
*/
export function rotation_x_same_step_classically_controlled(theta: number, qbit: QBit, bit: Bit): void;
/**
* @param {number} theta
* @param {QBit} qbit
* @param {Bit} bit
*/
export function rotation_x_classically_controlled(theta: number, qbit: QBit, bit: Bit): void;
/**
* @param {number} theta
* @param {QBit} qbit
*/
export function rotation_y(theta: number, qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_rotation_y(theta: number, c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_rotation_y(theta: number, c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} qbit
*/
export function rotation_y_same_step(theta: number, qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_rotation_y_same_step(theta: number, c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_rotation_y_same_step(theta: number, c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} qbit
* @param {Bit} bit
*/
export function rotation_y_same_step_classically_controlled(theta: number, qbit: QBit, bit: Bit): void;
/**
* @param {number} theta
* @param {QBit} qbit
* @param {Bit} bit
*/
export function rotation_y_classically_controlled(theta: number, qbit: QBit, bit: Bit): void;
/**
* @param {number} theta
* @param {QBit} qbit
*/
export function rotation_z(theta: number, qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_rotation_z(theta: number, c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_rotation_z(theta: number, c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} qbit
*/
export function rotation_z_same_step(theta: number, qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit
* @param {QBit} t_qbit
*/
export function controlled_rotation_z_same_step(theta: number, c_qbit: QBit, t_qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit
*/
export function controlled_controlled_rotation_z_same_step(theta: number, c_qbit_0: QBit, c_qbit_1: QBit, t_qbit: QBit): void;
/**
* @param {number} theta
* @param {QBit} qbit
* @param {Bit} bit
*/
export function rotation_z_same_step_classically_controlled(theta: number, qbit: QBit, bit: Bit): void;
/**
* @param {number} theta
* @param {QBit} qbit
* @param {Bit} bit
*/
export function rotation_z_classically_controlled(theta: number, qbit: QBit, bit: Bit): void;
/**
* @param {number} theta
* @param {QBit} qbit_0
* @param {QBit} qbit_1
*/
export function rotation_swap(theta: number, qbit_0: QBit, qbit_1: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit
* @param {QBit} t_qbit_0
* @param {QBit} t_qbit_1
*/
export function controlled_rotation_swap(theta: number, c_qbit: QBit, t_qbit_0: QBit, t_qbit_1: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit_0
* @param {QBit} t_qbit_1
*/
export function controlled_controlled_rotation_swap(theta: number, c_qbit_0: QBit, c_qbit_1: QBit, t_qbit_0: QBit, t_qbit_1: QBit): void;
/**
* @param {number} theta
* @param {QBit} qbit_0
* @param {QBit} qbit_1
*/
export function rotation_swap_same_step(theta: number, qbit_0: QBit, qbit_1: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit
* @param {QBit} t_qbit_0
* @param {QBit} t_qbit_1
*/
export function controlled_rotation_swap_same_step(theta: number, c_qbit: QBit, t_qbit_0: QBit, t_qbit_1: QBit): void;
/**
* @param {number} theta
* @param {QBit} c_qbit_0
* @param {QBit} c_qbit_1
* @param {QBit} t_qbit_0
* @param {QBit} t_qbit_1
*/
export function controlled_controlled_rotation_swap_same_step(theta: number, c_qbit_0: QBit, c_qbit_1: QBit, t_qbit_0: QBit, t_qbit_1: QBit): void;
/**
* @param {number} theta
* @param {QBit} qbit_0
* @param {QBit} qbit_1
* @param {Bit} bit
*/
export function rotation_swap_same_step_classically_controlled(theta: number, qbit_0: QBit, qbit_1: QBit, bit: Bit): void;
/**
* @param {number} theta
* @param {QBit} qbit_0
* @param {QBit} qbit_1
* @param {Bit} bit
*/
export function rotation_swap_classically_controlled(theta: number, qbit_0: QBit, qbit_1: QBit, bit: Bit): void;
/**
* @param {QBit} qbit
* @param {Bit} bit
*/
export function measurement_x(qbit: QBit, bit: Bit): void;
/**
* @param {QBit} qbit
* @param {Bit} bit
*/
export function measurement_y(qbit: QBit, bit: Bit): void;
/**
* @param {QBit} qbit
* @param {Bit} bit
*/
export function measurement_z(qbit: QBit, bit: Bit): void;
/**
* @param {QBit} qbit
* @param {Bit} bit
*/
export function measurement_x_same_step(qbit: QBit, bit: Bit): void;
/**
* @param {QBit} qbit
* @param {Bit} bit
*/
export function measurement_y_same_step(qbit: QBit, bit: Bit): void;
/**
* @param {QBit} qbit
* @param {Bit} bit
*/
export function measurement_z_same_step(qbit: QBit, bit: Bit): void;
/**
* @param {QBit} qbit
*/
export function reset(qbit: QBit): void;
/**
* @param {QBit} qbit
*/
export function reset_same_step(qbit: QBit): void;
export interface Complex {
    re: number;
    im: number;
}

/**
*/
export class Algorithm {
  free(): void;
/**
* @returns {AlgorithmResult}
*/
  run(): AlgorithmResult;
/**
* @returns {AlgorithmResult | undefined}
*/
  step(): AlgorithmResult | undefined;
/**
* @param {number} steps
* @returns {Algorithm}
*/
  intoStepper(steps: number): Algorithm;
}
/**
*/
export class AlgorithmResult {
  free(): void;
/**
* @returns {QuantumRegister}
*/
  quantumRegister(): QuantumRegister;
/**
* @returns {ClassicalRegister}
*/
  classicalRegister(): ClassicalRegister;
/**
*/
  log(): void;
}
/**
*/
export class Bit {
  free(): void;
}
/**
*/
export class ClassicalRegister {
  free(): void;
/**
* @returns {(boolean)[]}
*/
  state(): (boolean)[];
}
/**
*/
export class GateBuilder {
  free(): void;
/**
*/
  constructor();
/**
* @returns {Algorithm}
*/
  intoAlgorithm(): Algorithm;
/**
* @returns {QBit}
*/
  qbit(): QBit;
/**
* @param {number} size
* @returns {(QBit)[]}
*/
  qbits(size: number): (QBit)[];
/**
* @returns {Bit}
*/
  bit(): Bit;
/**
* @param {number} size
* @returns {(Bit)[]}
*/
  bits(size: number): (Bit)[];
}
/**
*/
export class QBit {
  free(): void;
}
/**
*/
export class QuantumRegister {
  free(): void;
/**
* Returns the array of all states
* @returns {Complex[]}
*/
  states(): Complex[];
/**
* Returns the states of this index
* @param {number} idx
* @returns {Complex | undefined}
*/
  state(idx: number): Complex | undefined;
/**
* Returns the probability of all states
* @returns {Float64Array}
*/
  amplitudes(): Float64Array;
/**
* Returns the probabilities of each qbit
* @returns {Float64Array}
*/
  probabilities(): Float64Array;
/**
* Returns the probability of a qbit
* @param {number} bit
* @returns {number}
*/
  probability(bit: number): number;
}