declare module '@qni/elements/src/angle-slider-element' {
  export const isAngleSliderElement: (arg: unknown) => arg is AngleSliderElement;
  export class AngleSliderElement extends HTMLElement {
      angle: string;
      radian: number;
      denominator: number;
      disabled: boolean;
      debug: boolean;
      private snapAngles;
      private angleSliderMachine;
      private angleSliderService;
      attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
      connectedCallback(): void;
      disconnectedCallback(): void;
      update(): void;
      private initInteraction;
      private startMove;
      private move;
      private endMove;
      private updateSnapAngles;
      private findSnapAngle;
      private proportionToRadian;
      private set left(value);
  }

}
declare module '@qni/elements/src/anti-control-gate-element' {
  import { SerializedAntiControlGateType } from '@qni/common';
  const AntiControlGateElement_base: import("@qni/elements/src/index").Constructor<import("./mixin/menuable").Menuable> & import(".").Constructor<import("./mixin/helpable").Helpable> & import(".").Constructor<import("./mixin/draggable").Draggable> & import(".").Constructor<import("./mixin/disableable").Disableable> & import(".").Constructor<import("./mixin/iconable").Iconable> & import(".").Constructor<import("./mixin/activateable").Activateable> & import(".").Constructor<import("./mixin/hoverable").Hoverable> & {
      new (): HTMLElement;
      prototype: HTMLElement;
  };
  export class AntiControlGateElement extends AntiControlGateElement_base {
      get operationType(): typeof SerializedAntiControlGateType;
      connectedCallback(): void;
      update(): void;
      toJson(): string;
  }
  export {};

}
declare module '@qni/elements/src/bloch-display-element' {
  import { SerializedBlochDisplayType } from '@qni/common';
  import { Instance as TippyInstance } from 'tippy.js';
  const BlochDisplayElement_base: import("@qni/elements/src/index").Constructor<import("./mixin/menuable").Menuable> & import(".").Constructor<import("./mixin/helpable").Helpable> & import(".").Constructor<import("./mixin/draggable").Draggable> & import(".").Constructor<import("./mixin/activateable").Activateable> & import(".").Constructor<import("./mixin/hoverable").Hoverable> & {
      new (): HTMLElement;
      prototype: HTMLElement;
  };
  export class BlochDisplayElement extends BlochDisplayElement_base {
      body: HTMLElement;
      vectorLine: HTMLElement;
      vectorEnd: HTMLElement;
      vector: HTMLElement;
      vectorEndCircles: HTMLElement[];
      x: number;
      y: number;
      z: number;
      popup: TippyInstance;
      get operationType(): typeof SerializedBlochDisplayType;
      showPopup(): void;
      private showInspector;
      private blochInspectorPopupContent;
      connectedCallback(): void;
      disconnectedCallback(): void;
      attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
      update(): void;
      toJson(): string;
      private updateBlochVector;
      private get d();
      private set d(value);
      private vectorLength;
      private set phi(value);
      private get phi();
      private phiRadian;
      private set theta(value);
      private get theta();
      private thetaRadian;
  }
  export {};

}
declare module '@qni/elements/src/button-group-element' {
  export class ButtonGroupElement extends HTMLElement {
      buttons: HTMLElement[];
      connectedCallback(): void;
      update(): void;
      activateButton(event: Event): void;
  }

}
declare module '@qni/elements/src/circle-notation-element' {
  import { Complex } from '@qni/common';
  export class CircleNotationElement extends HTMLElement {
      /** Number of qubits. */
      qubitCount: number;
      /** Size of qubit circles. */
      qubitCircleSize: 'xs' | 'sm' | 'base' | 'lg' | 'xl';
      /** Number of columns. */
      colCount: number;
      /** Number of rows. */
      rowCount: number;
      /** Control the horizontal padding of the inner container. */
      paddingX: number;
      /** Control the vertical padding of the inner container. */
      paddingY: number;
      /**
       * Number of rows/columns to render above/below the visible bounds.
       * This can help reduce flickering during scrolling.
       */
      overscanCount: number;
      /** Controls color phase mode ON/OFF */
      colorPhase: boolean;
      /** ID of qubit circle popup template element */
      qubitCirclePopupTemplateId: string;
      showQubitCirclePopupAmplitude: boolean;
      showQubitCirclePopupProbability: boolean;
      showQubitCirclePopupPhase: boolean;
      /** @internal */
      window: HTMLElement;
      /** @internal */
      innerContainer: HTMLElement;
      /** @internal */
      qubitCircles: HTMLElement[];
      visibleQubitCircleKets: number[];
      private mobile;
      private lastWindowScrollTop;
      private lastWindowScrollLeft;
      private lastColStartIndex;
      private lastColEndIndex;
      private lastRowStartIndex;
      private lastRowEndIndex;
      private qubitCirclePositions;
      private mobileMediaQuery;
      /** @internal */
      connectedCallback(): void;
      private startViewSizeChangeEventListener;
      private handleViewSizeChange;
      /** @internal */
      startBasicCircleNotationMode(): void;
      /** @internal */
      startColorPhaseMode(): void;
      /** @internal */
      attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
      private updateQubitCircleSize;
      private updateDimension;
      private updateVisibleQubitCircleKets;
      setAmplitudes(amplitudes: {
          [ket: number]: Complex;
      }): void;
      private renderShadowRoot;
      private get innerHeight();
      private get innerWidth();
      private get qubitCirclesAreaHeight();
      private get qubitCirclesAreaWidth();
      private get windowHeight();
      private get windowWidth();
      private resizeWindow;
      private resizeInnerContainer;
      private get qubitCircleSizePx();
      private drawQubitCircles;
      /** @internal */
      update(): void;
      private drawNewlyVisibleQubitCircles;
      private removeInvisibleQubitCircles;
      private allQubitCircleElements;
      private qubitCircleElement;
      private get gap();
      private get qubitCircleLineWidth();
      private get overscanColStartIndex();
      private get overscanColEndIndex();
      private get overscanRowStartIndex();
      private get overscanRowEndIndex();
      private get visibleColStartIndex();
      private get visibleColEndIndex();
      private get visibleRowStartIndex();
      private get visibleRowEndIndex();
      private get windowScrollTop();
      private get windowScrollLeft();
      /** @internal */
      showQubitCirclePopup(event: MouseEvent): void;
      /** @internal */
      hideQubitCirclePopup(event: MouseEvent): void;
      private get qubitCirclePopupTemplate();
  }

}
declare module '@qni/elements/src/circle-notation-panel-element' {
  import { CircleNotationElement } from '@qni/elements/src/circle-notation-element';
  export class CircleNotationPanelElement extends HTMLElement {
      circleNotation: CircleNotationElement;
      connectedCallback(): void;
      startBasicCircleNotationMode(): void;
      startColorPhaseMode(): void;
      private renderShadowRoot;
  }

}
declare module '@qni/elements/src/circuit-block-element' {
  export class CircuitBlockElement extends HTMLElement {
      comment: string;
      finalized: boolean;
      finalize(): void;
      connectedCallback(): void;
      update(): void;
  }

}
declare module '@qni/elements/src/circuit-dropzone-element' {
  import { CircuitStepElement } from '@qni/elements/src/circuit-step-element';
  import { Operation } from '@qni/elements/src/operation';
  export const isCircuitDropzoneElement: (arg: unknown) => arg is CircuitDropzoneElement;
  export class CircuitDropzoneElement extends HTMLElement {
      #private;
      occupied: boolean;
      operationName: string;
      inputWireQuantum: boolean;
      outputWireQuantum: boolean;
      connectTop: boolean;
      connectBottom: boolean;
      shadow: boolean;
      targets: string;
      debug: boolean;
      private circuitDropzoneMachine;
      private circuitDropzoneService;
      get noConnections(): boolean;
      get operation(): Operation | null;
      get snapTarget(): {
          x: number;
          y: number;
      };
      get resizeHandleSnapTarget(): {
          x: number;
          y: number;
      };
      toJson(): string | number;
      connectedCallback(): void;
      disconnectedCallback(): void;
      attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
      update(): void;
      put(operation: Operation): void;
      get circuitStep(): CircuitStepElement | null;
      private initDropzone;
      private snap;
      private unsnap;
      private dropOperation;
      private deleteOperation;
      private resizeOperation;
      private get wireSvg();
  }

}
declare module '@qni/elements/src/circuit-editor-element' {
  import { InspectorButtonElement } from '@qni/elements/src/inspector-button-element';
  import { QuantumCircuitElement } from '@qni/elements/src/quantum-circuit-element';
  export class CircuitEditorElement extends HTMLElement {
      debug: boolean;
      circuit: QuantumCircuitElement;
      inspectorButton: InspectorButtonElement;
      private circuitEditorMachine;
      private circuitEditorService;
      connectedCallback(): void;
      update(): void;
      private enableDragging;
      private enableResizing;
      private get activeOperation();
      private makeCircuitHoverable;
      private maybeDeactivateOperation;
      private activateOperation;
      private showOperationMenu;
      private showOperationInspectorIf;
      private showOperationInspectorAngle;
      private showOperationInspectorFlag;
      private setOperationIf;
      private setOperationAngle;
      private setOperationFlag;
      private grabOperation;
      private grabResizeHandle;
      private releaseResizeHandle;
      private releaseOperation;
      private resizeEnd;
      private endDraggingOperation;
      private dropOperation;
      private deleteOperation;
      private clickStep;
      private snapStep;
      private unsnapStep;
      private operationInSnapRange;
      private resizeHandleInSnapRange;
      private mouseEnterStep;
      private mouseLeaveStep;
      private mouseLeaveCircuit;
  }

}
declare module '@qni/elements/src/circuit-step-element' {
  import { ResizeableSpan, SerializedCircuitStep } from '@qni/common';
  import { Operation } from '@qni/elements/src/operation';
  import { CircuitBlockElement } from '@qni/elements/src/circuit-block-element';
  import { CircuitDropzoneElement } from '@qni/elements/src/circuit-dropzone-element';
  export const isCircuitStepElement: (arg: unknown) => arg is CircuitStepElement;
  type ConnectionProps = {
      disableCh: boolean;
      maxChControlGates: number;
      maxChTargetGates: number;
      disableCnot: boolean;
      maxCnotControlGates: number;
      maxCnotTargetGates: number;
      disableCy: boolean;
      maxCyControlGates: number;
      maxCyTargetGates: number;
      disableCz: boolean;
      maxCzControlGates: number;
      maxCzTargetGates: number;
      disableCphase: boolean;
      maxCphaseControlGates: number;
      maxCphaseTargetGates: number;
      disableCt: boolean;
      maxCtControlGates: number;
      maxCtTargetGates: number;
      disableCrnot: boolean;
      maxCrnotControlGates: number;
      maxCrnotTargetGates: number;
      disableCrx: boolean;
      maxCrxControlGates: number;
      maxCrxTargetGates: number;
      disableCry: boolean;
      maxCryControlGates: number;
      maxCryTargetGates: number;
      disableCrz: boolean;
      maxCrzControlGates: number;
      maxCrzTargetGates: number;
      disableCswap: boolean;
      maxCswapControlGates: number;
      disableSwap: boolean;
      disableControlControl: boolean;
      maxControlControlTargetGates: number;
      disablePhasePhase: boolean;
      maxPhasePhaseTargetGates: number;
  };
  export class CircuitStepElement extends HTMLElement {
      active: boolean;
      breakpoint: boolean;
      shadow: boolean;
      keep: boolean;
      debug: boolean;
      dropzones: CircuitDropzoneElement[];
      freeDropzones: CircuitDropzoneElement[];
      occupiedDropzones: CircuitDropzoneElement[];
      private circuitStepMachine;
      private circuitStepService;
      get maxOccupiedDropzoneBit(): 0 | ResizeableSpan;
      get wireCount(): number;
      get isInBlock(): boolean;
      get block(): CircuitBlockElement;
      connectedCallback(): void;
      attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
      update(): void;
      updateOperationAttributes(connectionProps?: ConnectionProps): void;
      private updateSwapConnections;
      private updatePhasePhaseConnections;
      private updateControlControlConnections;
      private updateControlledUConnections;
      private updateFreeDropzoneConnections;
      private controlBits;
      bit(dropzone: CircuitDropzoneElement): number;
      get isEmpty(): boolean;
      dropzoneAt(dropzoneIndex: number): CircuitDropzoneElement;
      get lastDropzone(): CircuitDropzoneElement;
      appendDropzone(): CircuitDropzoneElement;
      appendOperation(operation: Operation): void;
      private get swapGateDropzones();
      private get phaseGateDropzones();
      private get controlGateDropzones();
      private get antiControlGateDropzones();
      private numControlGateDropzones;
      private controllableDropzones;
      private dispatchUpdateEvent;
      private deleteOperation;
      private resizeOperation;
      private dispatchMouseenterEvent;
      private dispatchMouseleaveEvent;
      private maybeDispatchClickEvent;
      private snapDropzone;
      private unsnapDropzone;
      private unshadow;
      private occupyDropzone;
      serialize(): SerializedCircuitStep;
      private get operations();
      toJson(): string;
  }
  export {};

}
declare module '@qni/elements/src/control-gate-element' {
  import { SerializedControlGateType } from '@qni/common';
  const ControlGateElement_base: import("@qni/elements/src/index").Constructor<import("./mixin/menuable").Menuable> & import(".").Constructor<import("./mixin/helpable").Helpable> & import(".").Constructor<import("./mixin/draggable").Draggable> & import(".").Constructor<import("./mixin/disableable").Disableable> & import(".").Constructor<import("./mixin/iconable").Iconable> & import(".").Constructor<import("./mixin/activateable").Activateable> & import(".").Constructor<import("./mixin/hoverable").Hoverable> & {
      new (): HTMLElement;
      prototype: HTMLElement;
  };
  export class ControlGateElement extends ControlGateElement_base {
      get operationType(): typeof SerializedControlGateType;
      connectedCallback(): void;
      update(): void;
      toJson(): string;
  }
  export {};

}
declare module '@qni/elements/src/gate-carousel-element' {
  export class GateCarouselElement extends HTMLElement {
      currentGateSetIndex: number;
      contentClipper: HTMLElement;
      gateSets: HTMLElement[];
      dots: HTMLElement[];
      popinAnimationGates: HTMLElement[];
      connectedCallback(): void;
      attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
      private startBreakpointChangeEventListener;
      private startAnimation;
      private update;
      private iconHtml;
      private dotsHtml;
      private enableContentClipping;
      private disableContentClipping;
      private removePopinAnimationGates;
      prevGateSet(): void;
      nextGateSet(): void;
      private validateCurrentGateSetIndex;
      private toggleGateSets;
      private makeAllGateSetsVisible;
      private makeAllGateSetsInvisible;
      private get activeGateSet();
      private get gatesInActiveGateSet();
      private createPopinAnimationGates;
      private animatePopinAnimationGates;
      private toggleDots;
  }

}
declare module '@qni/elements/src/h-gate-element' {
  import { SerializedHGateType } from '@qni/common';
  export type HGateElementProps = {
      targets: number[];
      disabled?: boolean;
  };
  const HGateElement_base: import("@qni/elements/src/index").Constructor<import("./mixin").Menuable> & import(".").Constructor<import("./mixin").Helpable> & import(".").Constructor<import("./mixin").Ifable> & import(".").Constructor<import("./mixin").Controllable> & import(".").Constructor<import("./mixin").Draggable> & import(".").Constructor<import("./mixin").Disableable> & import(".").Constructor<import("./mixin").Iconable> & import(".").Constructor<import("./mixin").Activateable> & import(".").Constructor<import("./mixin").Hoverable> & {
      new (): HTMLElement;
      prototype: HTMLElement;
  };
  export class HGateElement extends HGateElement_base {
      get operationType(): typeof SerializedHGateType;
      connectedCallback(): void;
      update(): void;
      toJson(): string;
  }
  export {};

}
declare module '@qni/elements/src/index' {
  export { Complex } from '@qni/common';
  export * from '@qni/elements/src/operation';
  export * from '@qni/elements/src/util';
  export * from '@qni/elements/src/mixin/angleable';
  export * from '@qni/elements/src/mixin/constructor';
  export * from '@qni/elements/src/mixin/controllable';
  export * from '@qni/elements/src/mixin/flaggable';
  export * from '@qni/elements/src/mixin/ifable';
  export * from '@qni/elements/src/angle-slider-element';
  export * from '@qni/elements/src/button-group-element';
  export * from '@qni/elements/src/circle-notation-element';
  export * from '@qni/elements/src/circle-notation-panel-element';
  export * from '@qni/elements/src/gate-carousel-element';
  export * from '@qni/elements/src/inspector-button-element';
  export * from '@qni/elements/src/operation-inspector-element';
  export * from '@qni/elements/src/qubit-circle-element';
  export * from '@qni/elements/src/run-circuit-button-element';
  export * from '@qni/elements/src/slide-in-element';
  export * from '@qni/elements/src/anti-control-gate-element';
  export * from '@qni/elements/src/bloch-display-element';
  export * from '@qni/elements/src/circuit-block-element';
  export * from '@qni/elements/src/circuit-dropzone-element';
  export * from '@qni/elements/src/circuit-editor-element';
  export * from '@qni/elements/src/circuit-step-element';
  export * from '@qni/elements/src/control-gate-element';
  export * from '@qni/elements/src/h-gate-element';
  export * from '@qni/elements/src/measurement-gate-element';
  export * from '@qni/elements/src/palette-dropzone-element';
  export * from '@qni/elements/src/phase-gate-element';
  export * from '@qni/elements/src/qft-dagger-gate-element';
  export * from '@qni/elements/src/qft-gate-element';
  export * from '@qni/elements/src/quantum-circuit-element';
  export * from '@qni/elements/src/quantum-simulator-element';
  export * from '@qni/elements/src/rnot-gate-element';
  export * from '@qni/elements/src/rx-gate-element';
  export * from '@qni/elements/src/ry-gate-element';
  export * from '@qni/elements/src/rz-gate-element';
  export * from '@qni/elements/src/spacer-gate-element';
  export * from '@qni/elements/src/swap-gate-element';
  export * from '@qni/elements/src/t-gate-element';
  export * from '@qni/elements/src/write-gate-element';
  export * from '@qni/elements/src/x-gate-element';
  export * from '@qni/elements/src/y-gate-element';
  export * from '@qni/elements/src/z-gate-element';

}
declare module '@qni/elements/src/inspector-button-element' {
  import { Angleable, Ifable } from '@qni/elements/src/mixin/index';
  import { Operation } from '@qni/elements/src/operation';
  import { Instance as TippyInstance } from 'tippy.js';
  import { Flaggable } from '@qni/elements/src/mixin/flaggable';
  import { OperationInspectorElement } from '@qni/elements/src/operation-inspector-element';
  export class InspectorButtonElement extends HTMLElement {
      popup: TippyInstance;
      get isInspectorShown(): boolean;
      connectedCallback(): void;
      update(): void;
      showInspector(operation: Operation): void;
      showIfInspector(operation: Ifable): void;
      showAngleInspector(operation: Angleable): void;
      showFlagInspector(operation: Flaggable): void;
      get inspector(): OperationInspectorElement;
      private initPopup;
      private showPopup;
      private maybeHidePopup;
      private get popupContent();
  }

}
declare module '@qni/elements/src/measurement-gate-element' {
  import { SerializedMeasurementGateType } from '@qni/common';
  const MeasurementGateElement_base: import("@qni/elements/src/index").Constructor<import("./mixin/menuable").Menuable> & import(".").Constructor<import("./mixin/helpable").Helpable> & import(".").Constructor<import("./mixin/flaggable").Flaggable> & import(".").Constructor<import("./mixin/draggable").Draggable> & import(".").Constructor<import("./mixin/iconable").Iconable> & import(".").Constructor<import("./mixin/activateable").Activateable> & import(".").Constructor<import("./mixin/hoverable").Hoverable> & {
      new (): HTMLElement;
      prototype: HTMLElement;
  };
  export class MeasurementGateElement extends MeasurementGateElement_base {
      value: string;
      get operationType(): typeof SerializedMeasurementGateType;
      connectedCallback(): void;
      update(): void;
      toJson(): string;
  }
  export {};

}
declare module '@qni/elements/src/mixin/activateable' {
  import { Constructor } from '@qni/elements/src/mixin/constructor';
  export class Activateable {
      get active(): boolean;
      set active(value: boolean);
      activate(): void;
      deactivate(): void;
  }
  export function ActivateableMixin<TBase extends Constructor<HTMLElement>>(Base: TBase): Constructor<Activateable> & TBase;

}
declare module '@qni/elements/src/mixin/angleable' {
  import { Constructor } from '@qni/elements/src/mixin/constructor';
  export class Angleable {
      get angle(): string;
      set angle(value: string);
      get reducedAngle(): string;
      set reducedAngle(value: string);
  }
  export const isAngleable: (arg: unknown) => arg is Angleable;
  export function AngleableMixin<TBase extends Constructor<HTMLElement>>(Base: TBase): Constructor<Angleable> & TBase;

}
declare module '@qni/elements/src/mixin/constructor' {
  export type Constructor<T = unknown> = new (...args: any[]) => T;

}
declare module '@qni/elements/src/mixin/controllable' {
  import { Constructor } from '@qni/elements/src/mixin/constructor';
  export class Controllable {
      get controls(): number[];
      set controls(value: number[]);
      get antiControls(): number[];
      set antiControls(value: number[]);
      get isControlled(): boolean;
      get isAntiControlled(): boolean;
  }
  export const isControllable: (arg: unknown) => arg is Controllable;
  export function ControllableMixin<TBase extends Constructor<HTMLElement>>(Base: TBase): Constructor<Controllable> & TBase;

}
declare module '@qni/elements/src/mixin/disableable' {
  import { Constructor } from '@qni/elements/src/mixin/constructor';
  export class Disableable {
      get disabled(): boolean;
      set disabled(value: boolean);
      get enabled(): boolean;
      enable(): void;
      disable(): void;
  }
  export function DisableableMixin<TBase extends Constructor<HTMLElement>>(Base: TBase): Constructor<Disableable> & TBase;

}
declare module '@qni/elements/src/mixin/draggable' {
  import { CircuitDropzoneElement } from '@qni/elements/src/circuit-dropzone-element';
  import { Constructor } from '@qni/elements/src/mixin/constructor';
  import { PaletteDropzoneElement } from '@qni/elements/src/palette-dropzone-element';
  export const isDraggable: (arg: unknown) => arg is Draggable;
  export const isCircuitDropzoneElement: (arg: unknown) => arg is CircuitDropzoneElement;
  export const isPaletteDropzoneElement: (arg: unknown) => arg is PaletteDropzoneElement;
  export class Draggable {
      get operationX(): number;
      set operationX(value: number);
      get operationY(): number;
      set operationY(value: number);
      get draggable(): boolean;
      set draggable(value: boolean);
      get grabbed(): boolean;
      set grabbed(value: boolean);
      get dragging(): boolean;
      set dragging(value: boolean);
      get snapped(): boolean;
      set snapped(value: boolean);
      get bit(): number;
      set bit(value: number);
      get dropzone(): PaletteDropzoneElement | CircuitDropzoneElement | null;
      get snapRange(): number;
      set snapTargets(value: Array<{
          x: number;
          y: number;
      }>);
      initDraggable(): void;
  }
  export function DraggableMixin<TBase extends Constructor<HTMLElement>>(Base: TBase): Constructor<Draggable> & TBase;

}
declare module '@qni/elements/src/mixin/flaggable' {
  import { Constructor } from '@qni/elements/src/mixin/constructor';
  export class Flaggable {
      get flag(): string;
      set flag(value: string);
  }
  export const isFlaggable: (arg: unknown) => arg is Flaggable;
  export function FlaggableMixin<TBase extends Constructor<HTMLElement>>(Base: TBase): Constructor<Flaggable> & TBase;

}
declare module '@qni/elements/src/mixin/helpable' {
  import { Constructor } from '@qni/elements/src/mixin/constructor';
  export class Helpable {
      initHelp(): void;
      showHelp(): void;
      disableHelp(): void;
      get helpContent(): DocumentFragment | null;
  }
  export const isHelpable: (arg: unknown) => arg is Helpable;
  export function HelpableMixin<TBase extends Constructor<HTMLElement>>(Base: TBase): Constructor<Helpable> & TBase;

}
declare module '@qni/elements/src/mixin/hoverable' {
  import { Constructor } from '@qni/elements/src/mixin/constructor';
  export class Hoverable {
      get hoverable(): boolean;
      set hoverable(value: boolean);
  }
  export function HoverableMixin<TBase extends Constructor<HTMLElement>>(Base: TBase): Constructor<Hoverable> & TBase;

}
declare module '@qni/elements/src/mixin/iconable' {
  import { TemplateResult } from '@github/jtml';
  import { Constructor } from '@qni/elements/src/mixin/constructor';
  export class Iconable {
      iconHtml(svg: string): TemplateResult;
  }
  export function IconableMixin<TBase extends Constructor<HTMLElement>>(Base: TBase): Constructor<Iconable> & TBase;

}
declare module '@qni/elements/src/mixin/ifable' {
  import { Constructor } from '@qni/elements/src/mixin/constructor';
  export class Ifable {
      get if(): string;
      set if(value: string);
  }
  export const isIfable: (arg: unknown) => arg is Ifable;
  export function IfableMixin<TBase extends Constructor<HTMLElement>>(Base: TBase): Constructor<Ifable> & TBase;

}
declare module '@qni/elements/src/mixin/index' {
  export * from '@qni/elements/src/mixin/activateable';
  export * from '@qni/elements/src/mixin/angleable';
  export * from '@qni/elements/src/mixin/controllable';
  export * from '@qni/elements/src/mixin/disableable';
  export * from '@qni/elements/src/mixin/draggable';
  export * from '@qni/elements/src/mixin/flaggable';
  export * from '@qni/elements/src/mixin/helpable';
  export * from '@qni/elements/src/mixin/hoverable';
  export * from '@qni/elements/src/mixin/iconable';
  export * from '@qni/elements/src/mixin/ifable';
  export * from '@qni/elements/src/mixin/menuable';
  export * from '@qni/elements/src/mixin/resizeable';

}
declare module '@qni/elements/src/mixin/menuable' {
  import { Instance as TippyInstance } from 'tippy.js';
  import { Constructor } from '@qni/elements/src/mixin/constructor';
  export class Menuable {
      initMenu(): void;
      showMenu(): void;
      hideMenu(): void;
      menu: TippyInstance;
  }
  export const isMenuable: (arg: unknown) => arg is Menuable;
  export function MenuableMixin<TBase extends Constructor<HTMLElement>>(Base: TBase): Constructor<Menuable> & TBase;

}
declare module '@qni/elements/src/mixin/resizeable' {
  import { ResizeableSpan } from '@qni/common';
  import { Constructor } from '@qni/elements/src/mixin/constructor';
  export const isResizeable: (arg: unknown) => arg is Resizeable;
  export class Resizeable {
      set resizeable(value: boolean);
      get resizeHandle(): HTMLElement;
      set resizeHandleSnapTargets(values: Array<{
          x: number;
          y: number;
      }>);
      get span(): ResizeableSpan;
      set span(value: ResizeableSpan);
      initResizeable(): void;
  }
  export function ResizeableMixin<TBase extends Constructor<HTMLElement>>(Base: TBase): Constructor<Resizeable> & TBase;

}
declare module '@qni/elements/src/operation-inspector-element' {
  import { AngleSliderElement } from '@qni/elements/src/angle-slider-element';
  import { Angleable, Ifable } from '@qni/elements/src/mixin/index';
  import { Flaggable } from '@qni/elements/src/mixin/flaggable';
  import { Operation } from '@qni/elements/src/operation';
  export class OperationInspectorElement extends HTMLElement {
      ifInput: HTMLInputElement;
      angleInputLabel: HTMLLabelElement;
      angleInput: HTMLInputElement;
      angleSlider: AngleSliderElement;
      denominatorInput: HTMLInputElement;
      denominatorVariableLabel: HTMLSpanElement;
      denominatorLabel: HTMLSpanElement;
      reduceAngleFractionCheckbox: HTMLInputElement;
      flagInput: HTMLInputElement;
      conditionalGatePaneDisabled: boolean;
      anglePaneDisabled: boolean;
      conditionalFlagPaneDisabled: boolean;
      get if(): string;
      get angle(): string;
      get reducedAngle(): string;
      get reduceAngleFraction(): boolean;
      get flag(): string;
      set operation(operation: Ifable | Angleable | Flaggable | Operation);
      private clear;
      disableAllPanes(): void;
      connectedCallback(): void;
      update(): void;
      private changeAngle;
      private updateAngle;
      private backupCurrentPhi;
      private restoreOriginalPhi;
      private changeIf;
      private updateAngleInput;
      private changeFlag;
      private backupCurrentDenominator;
      private restoreOriginalDenominator;
      private changeDenominator;
      private changeReduceSetting;
  }

}
declare module '@qni/elements/src/operation' {
  import { AntiControlGateElement } from '@qni/elements/src/anti-control-gate-element';
  import { BlochDisplayElement } from '@qni/elements/src/bloch-display-element';
  import { ControlGateElement } from '@qni/elements/src/control-gate-element';
  import { HGateElement } from '@qni/elements/src/h-gate-element';
  import { MeasurementGateElement } from '@qni/elements/src/measurement-gate-element';
  import { PhaseGateElement } from '@qni/elements/src/phase-gate-element';
  import { QftDaggerGateElement } from '@qni/elements/src/qft-dagger-gate-element';
  import { QftGateElement } from '@qni/elements/src/qft-gate-element';
  import { RnotGateElement } from '@qni/elements/src/rnot-gate-element';
  import { RxGateElement } from '@qni/elements/src/rx-gate-element';
  import { RyGateElement } from '@qni/elements/src/ry-gate-element';
  import { RzGateElement } from '@qni/elements/src/rz-gate-element';
  import { SDaggerGateElement } from '@qni/elements/src/s-dagger-gate-element';
  import { SGateElement } from '@qni/elements/src/s-gate-element';
  import { SpacerGateElement } from '@qni/elements/src/spacer-gate-element';
  import { SwapGateElement } from '@qni/elements/src/swap-gate-element';
  import { TDaggerGateElement } from '@qni/elements/src/t-dagger-gate-element';
  import { TGateElement } from '@qni/elements/src/t-gate-element';
  import { WriteGateElement } from '@qni/elements/src/write-gate-element';
  import { XGateElement } from '@qni/elements/src/x-gate-element';
  import { YGateElement } from '@qni/elements/src/y-gate-element';
  import { ZGateElement } from '@qni/elements/src/z-gate-element';
  export type Operation = AntiControlGateElement | BlochDisplayElement | ControlGateElement | HGateElement | MeasurementGateElement | PhaseGateElement | QftDaggerGateElement | QftGateElement | RnotGateElement | RxGateElement | RyGateElement | RzGateElement | SDaggerGateElement | SGateElement | SpacerGateElement | SwapGateElement | TDaggerGateElement | TGateElement | WriteGateElement | XGateElement | YGateElement | ZGateElement;
  export const isOperation: (arg: unknown) => arg is Operation;
  export const isHGateElement: (arg: unknown) => arg is HGateElement;
  export const isXGateElement: (arg: unknown) => arg is XGateElement;
  export const isYGateElement: (arg: unknown) => arg is YGateElement;
  export const isZGateElement: (arg: unknown) => arg is ZGateElement;
  export const isPhaseGateElement: (arg: unknown) => arg is PhaseGateElement;
  export const isTGateElement: (arg: unknown) => arg is TGateElement;
  export const isTDaggerGateElement: (arg: unknown) => arg is TDaggerGateElement;
  export const isRnotGateElement: (arg: unknown) => arg is RnotGateElement;
  export const isRxGateElement: (arg: unknown) => arg is RxGateElement;
  export const isRyGateElement: (arg: unknown) => arg is RyGateElement;
  export const isRzGateElement: (arg: unknown) => arg is RzGateElement;
  export const isSGateElement: (arg: unknown) => arg is SGateElement;
  export const isSDaggerGateElement: (arg: unknown) => arg is SDaggerGateElement;
  export const isSpacerGateElement: (arg: unknown) => arg is SpacerGateElement;
  export const isSwapGateElement: (arg: unknown) => arg is SwapGateElement;
  export const isControlGateElement: (arg: unknown) => arg is ControlGateElement;
  export const isAntiControlGateElement: (arg: unknown) => arg is AntiControlGateElement;
  export const isBlochDisplayElement: (arg: unknown) => arg is BlochDisplayElement;
  export const isWriteGateElement: (arg: unknown) => arg is WriteGateElement;
  export const isMeasurementGateElement: (arg: unknown) => arg is MeasurementGateElement;

}
declare module '@qni/elements/src/palette-dropzone-element' {
  export class PaletteDropzoneElement extends HTMLElement {
      #private;
      connectedCallback(): void;
      disconnectedCallback(): void;
      update(): void;
      private initOperation;
      private get operation();
      private get operations();
      private newOperation;
      private deleteOperation;
      private assertOperation;
  }

}
declare module '@qni/elements/src/phase-gate-element' {
  import { SerializedPhaseGateType } from '@qni/common';
  export type PhaseGateElementProps = {
      targets: number[];
      disabled?: boolean;
  };
  const PhaseGateElement_base: import("@qni/elements/src/index").Constructor<import("./mixin/menuable").Menuable> & import(".").Constructor<import("./mixin/helpable").Helpable> & import(".").Constructor<import("./mixin/ifable").Ifable> & import(".").Constructor<import("./mixin/controllable").Controllable> & import(".").Constructor<import("./mixin/angleable").Angleable> & import(".").Constructor<import("./mixin/draggable").Draggable> & import(".").Constructor<import("./mixin/disableable").Disableable> & import(".").Constructor<import("./mixin/iconable").Iconable> & import(".").Constructor<import("./mixin/activateable").Activateable> & import(".").Constructor<import("./mixin/hoverable").Hoverable> & {
      new (): HTMLElement;
      prototype: HTMLElement;
  };
  export class PhaseGateElement extends PhaseGateElement_base {
      get operationType(): typeof SerializedPhaseGateType;
      connectedCallback(): void;
      update(): void;
      toJson(): string;
  }
  export {};

}
declare module '@qni/elements/src/qft-dagger-gate-element' {
  import { SerializedQftDaggerGateType } from '@qni/common';
  export type QftDaggerGateElementProps = {
      targets: number[];
  };
  const QftDaggerGateElement_base: import("@qni/elements/src/index").Constructor<import("./mixin").Menuable> & import(".").Constructor<import("./mixin").Helpable> & import(".").Constructor<import("./mixin").Resizeable> & import(".").Constructor<import("./mixin").Draggable> & import(".").Constructor<import("./mixin").Iconable> & import(".").Constructor<import("./mixin").Activateable> & import(".").Constructor<import("./mixin").Hoverable> & {
      new (): HTMLElement;
      prototype: HTMLElement;
  };
  export class QftDaggerGateElement extends QftDaggerGateElement_base {
      get operationType(): typeof SerializedQftDaggerGateType;
      connectedCallback(): void;
      update(): void;
      toJson(): string;
  }
  export {};

}
declare module '@qni/elements/src/qft-gate-element' {
  import { SerializedQftGateType } from '@qni/common';
  export type QftGateElementProps = {
      targets: number[];
  };
  const QftGateElement_base: import("@qni/elements/src/index").Constructor<import("./mixin").Menuable> & import(".").Constructor<import("./mixin").Helpable> & import(".").Constructor<import("./mixin").Resizeable> & import(".").Constructor<import("./mixin").Draggable> & import(".").Constructor<import("./mixin").Iconable> & import(".").Constructor<import("./mixin").Activateable> & import(".").Constructor<import("./mixin").Hoverable> & {
      new (): HTMLElement;
      prototype: HTMLElement;
  };
  export class QftGateElement extends QftGateElement_base {
      get operationType(): typeof SerializedQftGateType;
      connectedCallback(): void;
      update(): void;
      toJson(): string;
  }
  export {};

}
declare module '@qni/elements/src/quantum-circuit-element' {
  import { CircuitDropzoneElement } from '@qni/elements/src/circuit-dropzone-element';
  import { CircuitBlockElement } from '@qni/elements/src/circuit-block-element';
  import { CircuitStepElement } from '@qni/elements/src/circuit-step-element';
  import { HGateElementProps } from '@qni/elements/src/h-gate-element';
  import { Operation } from '@qni/elements/src/operation';
  import { PhaseGateElementProps } from '@qni/elements/src/phase-gate-element';
  import { QftDaggerGateElementProps } from '@qni/elements/src/qft-dagger-gate-element';
  import { QftGateElementProps } from '@qni/elements/src/qft-gate-element';
  import { ResizeableSpan, SerializedCircuitStep } from '@qni/common';
  import { RnotGateElementProps } from '@qni/elements/src/rnot-gate-element';
  import { RxGateElementProps } from '@qni/elements/src/rx-gate-element';
  import { RyGateElementProps } from '@qni/elements/src/ry-gate-element';
  import { RzGateElementProps } from '@qni/elements/src/rz-gate-element';
  import { SDaggerGateElementProps } from '@qni/elements/src/s-dagger-gate-element';
  import { SGateElementProps } from '@qni/elements/src/s-gate-element';
  import { TDaggerGateElementProps } from '@qni/elements/src/t-dagger-gate-element';
  import { TGateElementProps } from '@qni/elements/src/t-gate-element';
  import { XGateElementProps } from '@qni/elements/src/x-gate-element';
  import { YGateElementProps } from '@qni/elements/src/y-gate-element';
  import { ZGateElementProps } from '@qni/elements/src/z-gate-element';
  export type SnapTarget = {
      dropzone: CircuitDropzoneElement | null;
      stepIndex: number | null;
      wireIndex: number;
  };
  export type ResizeHandleSnapTarget = {
      dropzone: CircuitDropzoneElement | null;
      stepIndex: number | null;
      wireIndex: number;
  };
  const QuantumCircuitElement_base: import("@qni/elements/src/index").Constructor<import("./mixin").Hoverable> & {
      new (): HTMLElement;
      prototype: HTMLElement;
  };
  export class QuantumCircuitElement extends QuantumCircuitElement_base {
      minStepCount: number;
      minWireCount: number;
      editing: boolean;
      updateUrl: boolean;
      json: string;
      circuitTitle: string;
      debug: boolean;
      chDisabled: boolean;
      chMaxControlGates: number;
      chMaxTargetGates: number;
      cnotDisabled: boolean;
      cnotMaxControlGates: number;
      cnotMaxTargetGates: number;
      cyDisabled: boolean;
      cyMaxControlGates: number;
      cyMaxTargetGates: number;
      czDisabled: boolean;
      czMaxControlGates: number;
      czMaxTargetGates: number;
      cphaseDisabled: boolean;
      cphaseMaxControlGates: number;
      cphaseMaxTargetGates: number;
      ctDisabled: boolean;
      ctMaxControlGates: number;
      ctMaxTargetGates: number;
      crnotDisabled: boolean;
      crnotMaxControlGates: number;
      crnotMaxTargetGates: number;
      crxDisabled: boolean;
      crxMaxControlGates: number;
      crxMaxTargetGates: number;
      cryDisabled: boolean;
      cryMaxControlGates: number;
      cryMaxTargetGates: number;
      crzDisabled: boolean;
      crzMaxControlGates: number;
      crzMaxTargetGates: number;
      cswapDisabled: boolean;
      cswapMaxControlGates: number;
      swapDisabled: boolean;
      controlControlDisabled: boolean;
      controlControlMaxTargetGates: number;
      phasePhaseDisabled: boolean;
      phasePhaseMaxTargetGates: number;
      blocks: CircuitBlockElement[];
      private quantumCircuitMachine;
      private quantumCircuitService;
      private snapTargets;
      private resizeHandleSnapTargets;
      get wireCount(): number;
      get activeStepIndex(): number | null;
      get activeStep(): CircuitStepElement | null;
      fetchStepIndex(step: CircuitStepElement): number;
      get steps(): CircuitStepElement[];
      private get emptySteps();
      private get nonEmptySteps();
      private get largestStep();
      private appendMinimumSteps;
      /**
       * @category Circuit Step
       */
      stepAt(stepIndex: number): CircuitStepElement;
      /**
       * @category Circuit Step
       */
      addShadowStepAfter(stepIndex: number): CircuitStepElement;
      /**
       * @category Circuit Step
       */
      activateStep(step: CircuitStepElement): void;
      /**
       * @category Circuit Step
       */
      deactivateAllSteps(): void;
      /**
       * @category Circuit Step
       */
      setBreakpoint(step: CircuitStepElement): void;
      get breakpoint(): CircuitStepElement | null;
      private get dropzones();
      get operations(): Operation[];
      private get isVertical();
      connectedCallback(): void;
      attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
      private makeOperationsHoverable;
      private update;
      private updateStep;
      private updateStepOperationAttributes;
      private dispatchMouseleaveEvent;
      resize(): void;
      /**
       * @category Circuit Operation
       */
      h(...args: number[] | [HGateElementProps]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      x(...args: number[] | [XGateElementProps]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      y(...args: number[] | [YGateElementProps]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      z(...args: number[] | [ZGateElementProps]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      phase(...args: number[] | [string, ...number[]] | [PhaseGateElementProps]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      s(...args: number[] | [SGateElementProps]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      sDagger(...args: number[] | [SDaggerGateElementProps]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      t(...args: number[] | [TGateElementProps]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      tDagger(...args: number[] | [TDaggerGateElementProps]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      rnot(...args: number[] | [RnotGateElementProps]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      rx(...args: number[] | [RxGateElementProps]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      ry(...args: number[] | [RyGateElementProps]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      rz(...args: number[] | [RzGateElementProps]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      qft(span: ResizeableSpan, ...args: number[] | [QftGateElementProps]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      qftDagger(span: ResizeableSpan, ...args: number[] | [QftDaggerGateElementProps]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      swap(...targetBits: number[]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      control(...targetBits: number[]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      bloch(...targetBits: number[]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      write(value: '0' | '1', ...targetBits: number[]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      measure(...targetBits: number[]): QuantumCircuitElement;
      private applyOperationToTargets;
      /**
       * @category Circuit Operation
       */
      ch(control: number | number[], target: number | number[]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      cnot(control: number | number[], target: number | number[]): QuantumCircuitElement;
      cx: (control: number | number[], target: number | number[]) => QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      cy(control: number | number[], target: number | number[]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      cz(control: number | number[], target: number | number[]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      cphase(control: number | number[], target: number | number[]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      ct(control: number | number[], target: number | number[]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      crnot(control: number | number[], target: number | number[]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      crx(control: number | number[], target: number | number[]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      cry(control: number | number[], target: number | number[]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      crz(control: number | number[], target: number | number[]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      cswap(control: number | number[], target: number | number[]): QuantumCircuitElement;
      /**
       * @category Circuit Operation
       */
      cc(...targetBits: number[]): QuantumCircuitElement;
      private controlledU;
      private appendStep;
      private appendStepWithDropzones;
      private updateAllWires;
      activateOperation(operation: Operation): void;
      appendWire(): void;
      removeLastEmptyWires(): void;
      private removeEmptySteps;
      private loadFromJson;
      private ifVariable;
      private angleParameter;
      private appendMinimumWires;
      private updateWire;
      private updateChangedWire;
      /**
       * @category Drag and Drop
       */
      snapTargetAt(x: number, y: number): SnapTarget;
      /**
       * @category Drag and Drop
       */
      resizeHandleSnapTargetAt(x: number, y: number): SnapTarget;
      /**
       * @category Drag and Drop
       */
      setSnapTargets(operation: Operation): void;
      /**
       * @category Drag and Drop
       */
      setResizeHandleSnapTargets(operation: Operation): void;
      /**
       * @category Drag and Drop
       */
      updateSnapTargets(newDropzones: CircuitDropzoneElement[]): void;
      serialize(): SerializedCircuitStep[];
      clear(): void;
      toJson(): string;
  }
  export {};

}
declare module '@qni/elements/src/quantum-simulator-element' {
  import { CircleNotationElement } from '@qni/elements/src/circle-notation-element';
  import { QuantumCircuitElement } from '@qni/elements/src/quantum-circuit-element';
  import { RunCircuitButtonElement } from '@qni/elements/src/run-circuit-button-element';
  global {
      interface Window {
          debugServiceworker: boolean;
      }
  }
  export class QuantumSimulatorElement extends HTMLElement {
      updateUrl: boolean;
      circuit: QuantumCircuitElement;
      circleNotation: CircleNotationElement;
      runCircuitButtons: RunCircuitButtonElement[];
      worker: Worker;
      connectedCallback(): void;
      update(): void;
      clearCircuit(): void;
      private handleServiceWorkerMessage;
      private run;
      private freshRun;
      private _run;
      private setCircleNotationQubitCount;
      private runUnlessEditing;
      private get activeStepIndex();
      private maybeUpdateUrl;
  }

}
declare module '@qni/elements/src/qubit-circle-element' {
  export class QubitCircleElement extends HTMLElement {
      ket: number;
      qubitCount: number;
      amplitude: string;
      hidePhase: boolean;
      popupTemplateId: string;
      showPopupHeader: boolean;
      showPopupAmplitude: boolean;
      showPopupProbability: boolean;
      showPopupPhase: boolean;
      darkMode: boolean;
      connectedCallback(): void;
      update(): void;
      private addPopupEventListeners;
      private showPopup;
      private get magnitude();
      private get phase();
      private get phaseDeg();
      private get cssPhaseDeg();
      private hidePopup;
      private get popupTemplate();
  }

}
declare module '@qni/elements/src/rnot-gate-element' {
  import { SerializedRnotGateType } from '@qni/common';
  export type RnotGateElementProps = {
      targets: number[];
      disabled?: boolean;
  };
  const RnotGateElement_base: import("@qni/elements/src/index").Constructor<import("./mixin/menuable").Menuable> & import(".").Constructor<import("./mixin/helpable").Helpable> & import(".").Constructor<import("./mixin/ifable").Ifable> & import(".").Constructor<import("./mixin/controllable").Controllable> & import(".").Constructor<import("./mixin/draggable").Draggable> & import(".").Constructor<import("./mixin/disableable").Disableable> & import(".").Constructor<import("./mixin/iconable").Iconable> & import(".").Constructor<import("./mixin/activateable").Activateable> & import(".").Constructor<import("./mixin/hoverable").Hoverable> & {
      new (): HTMLElement;
      prototype: HTMLElement;
  };
  export class RnotGateElement extends RnotGateElement_base {
      get operationType(): typeof SerializedRnotGateType;
      connectedCallback(): void;
      update(): void;
      toJson(): string;
  }
  export {};

}
declare module '@qni/elements/src/run-circuit-button-element' {
  export class RunCircuitButtonElement extends HTMLElement {
      running: boolean;
      debug: boolean;
      body: HTMLElement;
      ripple: HTMLElement | undefined;
      private runCircuitButtonMachine;
      private runCircuitButtonService;
      connectedCallback(): void;
      attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
      update(): void;
      private handleClickEvent;
      private get reloadIcon();
      private get tailSpinIcon();
  }

}
declare module '@qni/elements/src/rx-gate-element' {
  import { SerializedRxGateType } from '@qni/common';
  export type RxGateElementProps = {
      targets: number[];
      disabled?: boolean;
  };
  const RxGateElement_base: import("@qni/elements/src/index").Constructor<import("./mixin/menuable").Menuable> & import(".").Constructor<import("./mixin/helpable").Helpable> & import(".").Constructor<import("./mixin/ifable").Ifable> & import(".").Constructor<import("./mixin/controllable").Controllable> & import(".").Constructor<import("./mixin/angleable").Angleable> & import(".").Constructor<import("./mixin/draggable").Draggable> & import(".").Constructor<import("./mixin/disableable").Disableable> & import(".").Constructor<import("./mixin/iconable").Iconable> & import(".").Constructor<import("./mixin/activateable").Activateable> & import(".").Constructor<import("./mixin/hoverable").Hoverable> & {
      new (): HTMLElement;
      prototype: HTMLElement;
  };
  export class RxGateElement extends RxGateElement_base {
      get operationType(): typeof SerializedRxGateType;
      connectedCallback(): void;
      update(): void;
      toJson(): string;
  }
  export {};

}
declare module '@qni/elements/src/ry-gate-element' {
  import { SerializedRyGateType } from '@qni/common';
  export type RyGateElementProps = {
      targets: number[];
      disabled?: boolean;
  };
  const RyGateElement_base: import("@qni/elements/src/index").Constructor<import("./mixin/menuable").Menuable> & import(".").Constructor<import("./mixin/helpable").Helpable> & import(".").Constructor<import("./mixin/ifable").Ifable> & import(".").Constructor<import("./mixin/controllable").Controllable> & import(".").Constructor<import("./mixin/angleable").Angleable> & import(".").Constructor<import("./mixin/draggable").Draggable> & import(".").Constructor<import("./mixin/disableable").Disableable> & import(".").Constructor<import("./mixin/iconable").Iconable> & import(".").Constructor<import("./mixin/activateable").Activateable> & import(".").Constructor<import("./mixin/hoverable").Hoverable> & {
      new (): HTMLElement;
      prototype: HTMLElement;
  };
  export class RyGateElement extends RyGateElement_base {
      get operationType(): typeof SerializedRyGateType;
      connectedCallback(): void;
      update(): void;
      toJson(): string;
  }
  export {};

}
declare module '@qni/elements/src/rz-gate-element' {
  import { SerializedRzGateType } from '@qni/common';
  export type RzGateElementProps = {
      targets: number[];
      disabled?: boolean;
  };
  const RzGateElement_base: import("@qni/elements/src/index").Constructor<import("./mixin/menuable").Menuable> & import(".").Constructor<import("./mixin/helpable").Helpable> & import(".").Constructor<import("./mixin/ifable").Ifable> & import(".").Constructor<import("./mixin/controllable").Controllable> & import(".").Constructor<import("./mixin/angleable").Angleable> & import(".").Constructor<import("./mixin/draggable").Draggable> & import(".").Constructor<import("./mixin/disableable").Disableable> & import(".").Constructor<import("./mixin/iconable").Iconable> & import(".").Constructor<import("./mixin/activateable").Activateable> & import(".").Constructor<import("./mixin/hoverable").Hoverable> & {
      new (): HTMLElement;
      prototype: HTMLElement;
  };
  export class RzGateElement extends RzGateElement_base {
      get operationType(): typeof SerializedRzGateType;
      connectedCallback(): void;
      update(): void;
      toJson(): string;
  }
  export {};

}
declare module '@qni/elements/src/s-dagger-gate-element' {
  import { SerializedSDaggerGateType } from '@qni/common';
  export type SDaggerGateElementProps = {
      targets: number[];
      disabled?: boolean;
  };
  const SDaggerGateElement_base: import("@qni/elements/src/index").Constructor<import("./mixin/menuable").Menuable> & import(".").Constructor<import("./mixin/helpable").Helpable> & import(".").Constructor<import("./mixin/ifable").Ifable> & import(".").Constructor<import("./mixin/controllable").Controllable> & import(".").Constructor<import("./mixin/draggable").Draggable> & import(".").Constructor<import("./mixin/disableable").Disableable> & import(".").Constructor<import("./mixin/iconable").Iconable> & import(".").Constructor<import("./mixin/activateable").Activateable> & import(".").Constructor<import("./mixin/hoverable").Hoverable> & {
      new (): HTMLElement;
      prototype: HTMLElement;
  };
  export class SDaggerGateElement extends SDaggerGateElement_base {
      get operationType(): typeof SerializedSDaggerGateType;
      connectedCallback(): void;
      update(): void;
      toJson(): string;
  }
  export {};

}
declare module '@qni/elements/src/s-gate-element' {
  import { SerializedSGateType } from '@qni/common';
  export type SGateElementProps = {
      targets: number[];
      disabled?: boolean;
  };
  const SGateElement_base: import("@qni/elements/src/index").Constructor<import("./mixin/menuable").Menuable> & import(".").Constructor<import("./mixin/helpable").Helpable> & import(".").Constructor<import("./mixin/ifable").Ifable> & import(".").Constructor<import("./mixin/controllable").Controllable> & import(".").Constructor<import("./mixin/draggable").Draggable> & import(".").Constructor<import("./mixin/disableable").Disableable> & import(".").Constructor<import("./mixin/iconable").Iconable> & import(".").Constructor<import("./mixin/activateable").Activateable> & import(".").Constructor<import("./mixin/hoverable").Hoverable> & {
      new (): HTMLElement;
      prototype: HTMLElement;
  };
  export class SGateElement extends SGateElement_base {
      get operationType(): typeof SerializedSGateType;
      connectedCallback(): void;
      update(): void;
      toJson(): string;
  }
  export {};

}
declare module '@qni/elements/src/slide-in-element' {
  export class SlideInElement extends HTMLElement {
      direction: 'up' | 'down' | '';
      directionDesktop: 'up' | 'down' | '';
      duration: number;
      marginTop: number;
      marginBottom: number;
      private mobile;
      connectedCallback(): void;
      private startViewSizeChangeEventListener;
      private handleViewSizeChange;
      private setMobileBreakpointFlag;
      private prepareAnimation;
      private startAnimation;
      private renderShadowRoot;
  }

}
declare module '@qni/elements/src/spacer-gate-element' {
  import { SerializedSpacerGateType } from '@qni/common';
  export type SpacerGateElementProps = {
      targets: number[];
  };
  const SpacerGateElement_base: import("@qni/elements/src/index").Constructor<import("./mixin").Menuable> & import(".").Constructor<import("./mixin").Helpable> & import(".").Constructor<import("./mixin").Draggable> & import(".").Constructor<import("./mixin").Disableable> & import(".").Constructor<import("./mixin").Iconable> & import(".").Constructor<import("./mixin").Activateable> & import(".").Constructor<import("./mixin").Hoverable> & {
      new (): HTMLElement;
      prototype: HTMLElement;
  };
  export class SpacerGateElement extends SpacerGateElement_base {
      get operationType(): typeof SerializedSpacerGateType;
      connectedCallback(): void;
      update(): void;
      toJson(): string;
  }
  export {};

}
declare module '@qni/elements/src/swap-gate-element' {
  import { SerializedSwapGateType } from '@qni/common';
  const SwapGateElement_base: import("@qni/elements/src/index").Constructor<import("./mixin/menuable").Menuable> & import(".").Constructor<import("./mixin/helpable").Helpable> & import(".").Constructor<import("./mixin/controllable").Controllable> & import(".").Constructor<import("./mixin/draggable").Draggable> & import(".").Constructor<import("./mixin/disableable").Disableable> & import(".").Constructor<import("./mixin/iconable").Iconable> & import(".").Constructor<import("./mixin/activateable").Activateable> & import(".").Constructor<import("./mixin/hoverable").Hoverable> & {
      new (): HTMLElement;
      prototype: HTMLElement;
  };
  export class SwapGateElement extends SwapGateElement_base {
      get operationType(): typeof SerializedSwapGateType;
      connectedCallback(): void;
      update(): void;
      toJson(): string;
  }
  export {};

}
declare module '@qni/elements/src/t-dagger-gate-element' {
  import { SerializedTDaggerGateType } from '@qni/common';
  export type TDaggerGateElementProps = {
      targets: number[];
      disabled?: boolean;
  };
  const TDaggerGateElement_base: import("@qni/elements/src/index").Constructor<import("./mixin/menuable").Menuable> & import(".").Constructor<import("./mixin/helpable").Helpable> & import(".").Constructor<import("./mixin/ifable").Ifable> & import(".").Constructor<import("./mixin/controllable").Controllable> & import(".").Constructor<import("./mixin/draggable").Draggable> & import(".").Constructor<import("./mixin/disableable").Disableable> & import(".").Constructor<import("./mixin/iconable").Iconable> & import(".").Constructor<import("./mixin/activateable").Activateable> & import(".").Constructor<import("./mixin/hoverable").Hoverable> & {
      new (): HTMLElement;
      prototype: HTMLElement;
  };
  export class TDaggerGateElement extends TDaggerGateElement_base {
      get operationType(): typeof SerializedTDaggerGateType;
      connectedCallback(): void;
      update(): void;
      toJson(): string;
  }
  export {};

}
declare module '@qni/elements/src/t-gate-element' {
  import { SerializedTGateType } from '@qni/common';
  export type TGateElementProps = {
      targets: number[];
      disabled?: boolean;
  };
  const TGateElement_base: import("@qni/elements/src/index").Constructor<import("./mixin/menuable").Menuable> & import(".").Constructor<import("./mixin/helpable").Helpable> & import(".").Constructor<import("./mixin/ifable").Ifable> & import(".").Constructor<import("./mixin/controllable").Controllable> & import(".").Constructor<import("./mixin/draggable").Draggable> & import(".").Constructor<import("./mixin/disableable").Disableable> & import(".").Constructor<import("./mixin/iconable").Iconable> & import(".").Constructor<import("./mixin/activateable").Activateable> & import(".").Constructor<import("./mixin/hoverable").Hoverable> & {
      new (): HTMLElement;
      prototype: HTMLElement;
  };
  export class TGateElement extends TGateElement_base {
      get operationType(): typeof SerializedTGateType;
      connectedCallback(): void;
      update(): void;
      toJson(): string;
  }
  export {};

}
declare module '@qni/elements/src/util' {
  export function isNumeric(value: string): boolean;
  export function forceSigned(value: number, digits?: number): string;

}
declare module '@qni/elements/src/write-gate-element' {
  import { SerializedWrite0GateType, SerializedWrite1GateType } from '@qni/common';
  const WriteGateElement_base: import("@qni/elements/src/index").Constructor<import("./mixin/menuable").Menuable> & import(".").Constructor<import("./mixin/helpable").Helpable> & import(".").Constructor<import("./mixin/draggable").Draggable> & import(".").Constructor<import("./mixin/iconable").Iconable> & import(".").Constructor<import("./mixin/activateable").Activateable> & import(".").Constructor<import("./mixin/hoverable").Hoverable> & {
      new (): HTMLElement;
      prototype: HTMLElement;
  };
  export class WriteGateElement extends WriteGateElement_base {
      value: string;
      get operationType(): typeof SerializedWrite0GateType | typeof SerializedWrite1GateType;
      connectedCallback(): void;
      update(): void;
      toJson(): string;
  }
  export {};

}
declare module '@qni/elements/src/x-gate-element' {
  import { SerializedXGateType } from '@qni/common';
  export type XGateElementProps = {
      targets: number[];
      disabled?: boolean;
  };
  const XGateElement_base: import("@qni/elements/src/index").Constructor<import("./mixin/menuable").Menuable> & import(".").Constructor<import("./mixin/helpable").Helpable> & import(".").Constructor<import("./mixin/ifable").Ifable> & import(".").Constructor<import("./mixin/controllable").Controllable> & import(".").Constructor<import("./mixin/draggable").Draggable> & import(".").Constructor<import("./mixin/disableable").Disableable> & import(".").Constructor<import("./mixin/iconable").Iconable> & import(".").Constructor<import("./mixin/activateable").Activateable> & import(".").Constructor<import("./mixin/hoverable").Hoverable> & {
      new (): HTMLElement;
      prototype: HTMLElement;
  };
  export class XGateElement extends XGateElement_base {
      get operationType(): typeof SerializedXGateType;
      connectedCallback(): void;
      update(): void;
      toJson(): string;
  }
  export {};

}
declare module '@qni/elements/src/y-gate-element' {
  import { SerializedYGateType } from '@qni/common';
  export type YGateElementProps = {
      targets: number[];
      disabled?: boolean;
  };
  const YGateElement_base: import("@qni/elements/src/index").Constructor<import("./mixin/menuable").Menuable> & import(".").Constructor<import("./mixin/helpable").Helpable> & import(".").Constructor<import("./mixin/ifable").Ifable> & import(".").Constructor<import("./mixin/controllable").Controllable> & import(".").Constructor<import("./mixin/draggable").Draggable> & import(".").Constructor<import("./mixin/disableable").Disableable> & import(".").Constructor<import("./mixin/iconable").Iconable> & import(".").Constructor<import("./mixin/activateable").Activateable> & import(".").Constructor<import("./mixin/hoverable").Hoverable> & {
      new (): HTMLElement;
      prototype: HTMLElement;
  };
  export class YGateElement extends YGateElement_base {
      get operationType(): typeof SerializedYGateType;
      connectedCallback(): void;
      update(): void;
      toJson(): string;
  }
  export {};

}
declare module '@qni/elements/src/z-gate-element' {
  import { SerializedZGateType } from '@qni/common';
  export type ZGateElementProps = {
      targets: number[];
      disabled?: boolean;
  };
  const ZGateElement_base: import("@qni/elements/src/index").Constructor<import("./mixin/menuable").Menuable> & import(".").Constructor<import("./mixin/helpable").Helpable> & import(".").Constructor<import("./mixin/ifable").Ifable> & import(".").Constructor<import("./mixin/controllable").Controllable> & import(".").Constructor<import("./mixin/draggable").Draggable> & import(".").Constructor<import("./mixin/disableable").Disableable> & import(".").Constructor<import("./mixin/iconable").Iconable> & import(".").Constructor<import("./mixin/activateable").Activateable> & import(".").Constructor<import("./mixin/hoverable").Hoverable> & {
      new (): HTMLElement;
      prototype: HTMLElement;
  };
  export class ZGateElement extends ZGateElement_base {
      get operationType(): typeof SerializedZGateType;
      connectedCallback(): void;
      update(): void;
      toJson(): string;
  }
  export {};

}
declare module '@qni/elements' {
  import main = require('@qni/elements/src/index');
  export = main;
}