constructor(graph: Remath, initialState?: INodeState) {
    super(initialState);
    this._graph = graph;
    this._id = (initialState && initialState.id) || genId();
    this._providers = observable.map<INode>();
    this._dependents = observable.map<INode>();
 }

 public constructor(props: KeyToYubiKeyProps) {
   this.fingerprint = props.fingerprint;
   this.card_id = props.card_id;
   this.slot_id = observable.box(props.slot_id);
   this.passphrase = observable.box(props.passphrase);
   this.admin_pin = props.admin_pin || new Pin();
 }

 public constructor(props: PinProps = {}) {
   if (props.pin) {
     this.pin = observable.box(props.pin);
   } else if (props._pin) {
     this.pin = props._pin;
   } else {
     this.pin = observable.box('');
   }
   this.match = props.match || new RegExp(PinDefaultRegex);
 }

 constructor(val?: boolean|NestedFlag, value = false) {
   super('NestedFlag');
   this.children = [];
   if (typeof(val) == 'boolean' || !val) {
     this.parent = undefined;
     this.value = observable.box(!!val);
   } else {
     this.parent = val;
     this.parent.children.push(this);
     this.value = observable.box(undefined);
   }
 }

    it('Adding variable whose formula references a non-existent symbol', () => {
        const remath = new Remath();
        let view: ObservableMap<string> = observable.map<string>();
        const render = sinon.spy(() => {
            renderCells(remath, view);
        });
        autorun(render);

        // add a
        const a = remath.addCell({
            symbol: 'a',
            formula: '= b + 10'
        });
        expect(render.callCount).to.equal(2);
        expect(view.get('a')).to.equal('sym:a,formula:b + 10,val:NaN,disp:#REF?');

        // add b = 30
        runInAction(() => {
            const b = remath.addCell({
                symbol: 'b',
                formula: '=30'
            });
        });
        expect(view.get('b')).to.equal('sym:b,formula:30,val:30,disp:30');
        expect(view.get('a')).to.equal('sym:a,formula:b + 10,val:40,disp:40');
    });

 constructor(warrent: Warrent/* , contentReg = '.' */) {
   super('ViewWarrent');
   this.warrent = warrent;
   // this.contentReg = contentReg;
   this._approved = observable.box(false);
   // this.min = 0;
   // this.max = 0;
 }

 public constructor(v: Date, e: string) {
   super('DateValue');
   this.errText = e;
   this.date = observable.box(undefined);
   this.date.observe(action((chg: IValueDidChange<Date>) => {
     const f = format_date(chg.newValue);
     this.formatDate.set(f);
     // chg.newValue.setHours(0);
     // chg.newValue.setMinutes(0);
     // chg.newValue.setSeconds(0);
     // chg.newValue.setMilliseconds(0);
     // console.log('observe fix', chg.newValue);
   }));
   this.formatDate = observable.box(undefined);
   this.formatDate.observe(action((chg: IValueDidChange<string>) => {
     this.date.set(new Date(chg.newValue));
   }));
   action(() => this.formatDate.set(format_date(v)))();
 }

    it('throws if an undo instance is called twice', () => {
        let object = observable.map({ key: 2 });
        let undoableAction = action('updateMap')(() => {
            object.set('key', 5);
        });

        let undoResult = createUndo('updateMap')(undoableAction);
        undoResult();

        expect(undoResult).toThrow();
    });

 constructor(warrents: Warrents, diceWares: DiceWare[], smartCardId: string) {
   this.warrents = warrents;
   this.smartCardId = observable.box(smartCardId);
   this.readOnly = new NestedFlag(false);
   this.common = new SimpleKeyCommon(warrents, this.readOnly);
   this.passPhrase = PassPhrase.createDoublePasswords(8, new Warrents(this.warrents.map(w => w)), diceWares,
     CharFormat.wildcard(), 'PassPhrase error', ' ', 1);
   this.adminKey = PassPhrase.createPerWarrent(new Warrents(this.warrents.map(w => w)), null,
     CharFormat.decNumber(), 'adminpin error', '', 8, 8);
   const me = (new Warrents()).add(warrents.first());
   this.userKey = PassPhrase.createPerWarrent(me, null, CharFormat.decNumber(), 'userPin Error', '', 6, 8);
 }