/*
* This file is auto-generated using abi-gen. Any changes will be reverted
*/

// Needed for the promisifed events, some contracts don't have events
// tslint:disable:no-unused-variable
import { DecodedLogEntryEvent, DecodedLogEntry, DecodedTransactionReceipt } from "@joincivil/typescript-types";
// tslint:enable:no-unused-variable
import "rxjs/add/operator/distinctUntilChanged";

import {Contract} from "web3-eth-contract";
import {TransactionConfig, TransactionConfig as SendOptions} from "web3-core";

import { bindNestedAll, isDefined, CivilErrors } from "@joincivil/utils";
import * as Debug from "debug";

import { EthAddress, TxHash } from "@joincivil/typescript-types";
import { streamifyEvent } from "../../../contracts/utils/contracts";
import { EthApi, currentNetwork } from "@joincivil/ethapi";
import { BaseContract } from "../../basecontract";
import { artifacts } from "../artifacts";


// hack(dankins): abi-gen things these are bignumber.js, but they are actually returned as strings
// https://github.com/0xProject/0x-monorepo/blob/development/packages/abi-gen/src/utils.ts#L64
type BigNumber = string;

const debug = Debug("civil:contracts:CivilTokenControllerContract");
export class CivilTokenControllerContract extends BaseContract {
// tslint:disable:member-ordering
public static async singletonTrusted(ethApi: EthApi): Promise<CivilTokenControllerContract|undefined> {
  if (!artifacts.CivilTokenController.networks) {
  debug("Trying to get singleton from contract without any singleton data");
  return undefined;
  }
  const networkId = (await currentNetwork(ethApi)).toString();
  const networkData = artifacts.CivilTokenController.networks[networkId];
  if (!networkData) {
  debug("Failed to find network data for network ID " + networkId + ". Supported networks: " +
  Object.keys(artifacts.CivilTokenController.networks));
  return undefined;
  }
  return CivilTokenControllerContract.atUntrusted(ethApi, networkData.address);
  }
  public static atUntrusted(ethApi: EthApi, address: EthAddress): CivilTokenControllerContract {
    const contract = ethApi.getContractClass(artifacts.CivilTokenController.abi, address);
    return new CivilTokenControllerContract(contract, ethApi);
  }
  // TODO(ritave): This code won't work with smart-contracts with library links
  // see [ch429] in Clubhouse
  public static deployTrusted = {
  async sendTransactionAsync(
  ethApi: EthApi,
  options: SendOptions): Promise<string> {
    if (!options.gas) {
    options.gas = await CivilTokenControllerContract.deployTrusted
    .estimateGasAsync(
    ethApi,
    );
    }
    if (!options.gasPrice) {
      options.gasPrice = (await ethApi.getGasPrice()).toString();
    }
    const clazz = ethApi.getContractClass(artifacts.CivilTokenController.abi);


    return new Promise( (resolve, reject) => {
      /* There's a bug in Metamask, this callback should be called twice, first when the transaction
      * gets into mempool, and second when it's mined. But it's called only once, so we have to resolve
      * the contract on our own
      */
      const tx = clazz.deploy({data: artifacts.CivilTokenController.bytecode, arguments: []}).send(options);

      return tx.once("transactionHash", resolve)
    })


        },
        async estimateGasAsync(
        ethApi: EthApi,
        ): Promise<number> {
          const clazz = ethApi.getContractClass(artifacts.CivilTokenController.abi);
          const contractData = clazz.deploy({
            data: artifacts.CivilTokenController.bytecode, 
            arguments: []
          }).encodeABI();

          return ethApi.estimateGas({data: contractData});
          },
          };
// tslint:disable:variable-name
public SUCCESS_CODE = {
  async callAsync(   ): Promise<BigNumber> {
    const self = this as CivilTokenControllerContract;
    return self.instance.methods.SUCCESS_CODE().call();
  }
}
public addToCivilians = {
  async sendTransactionAsync(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<TxHash> {
    const self = this as CivilTokenControllerContract;
    const txOptions: TransactionConfig = { ...self.configuration.txDefaults, ...txData };
    debug(`addToCivilians(operator: string,
)`);
    debug("addToCivilians: txOptions:", txOptions);
    debug("addToCivilians: Sending with:",  operator,
  );
    txOptions.to = self.instance.options.address;
    txOptions.data = self.instance.methods.addToCivilians(operator,
).encodeABI();

    if (!isDefined(txOptions.gas)) {
      txOptions.gas = await self.ethApi.estimateGas(txOptions);
    }
    if (!isDefined(txOptions.gasPrice)) {
      const gasPricePromise = self.ethApi.getGasPriceString()
      txOptions.gasPrice = (await gasPricePromise).toString(); 
      debug("addToCivilians: new gas price: ", txOptions.gasPrice);
    }

    return self.ethApi.sendTransaction(txOptions)
  },
  async estimateGasAsync(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<number> {
    const self = this as CivilTokenControllerContract;
    const estimateGas = self.instance.methods.addToCivilians(operator,
).estimateGas

    try {
      const estimate = Math.floor(await estimateGas(txData) * self.configuration.estimationMultiplier);
      debug("addToCivilians: Gas estimation:", estimate);
      return estimate;
    } catch (e) {
      debug("addToCivilians: Gas estimation failed, only sensible error is EVM error", e);
      throw new Error(CivilErrors.EvmException);
    }
  },
  async getRaw(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<TransactionConfig> {
      const self = this as CivilTokenControllerContract;
      const options: TransactionConfig = {... txData};
      if (!isDefined(options.gas)) {
        options.gas = await self.addToCivilians.estimateGasAsync(
      operator,
      options,
      );
      }
      options.data = self.instance.methods.addToCivilians(operator,
).encodeABI();
      return options;
  },
};
public removeFromUnlocked = {
  async sendTransactionAsync(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<TxHash> {
    const self = this as CivilTokenControllerContract;
    const txOptions: TransactionConfig = { ...self.configuration.txDefaults, ...txData };
    debug(`removeFromUnlocked(operator: string,
)`);
    debug("removeFromUnlocked: txOptions:", txOptions);
    debug("removeFromUnlocked: Sending with:",  operator,
  );
    txOptions.to = self.instance.options.address;
    txOptions.data = self.instance.methods.removeFromUnlocked(operator,
).encodeABI();

    if (!isDefined(txOptions.gas)) {
      txOptions.gas = await self.ethApi.estimateGas(txOptions);
    }
    if (!isDefined(txOptions.gasPrice)) {
      const gasPricePromise = self.ethApi.getGasPriceString()
      txOptions.gasPrice = (await gasPricePromise).toString(); 
      debug("removeFromUnlocked: new gas price: ", txOptions.gasPrice);
    }

    return self.ethApi.sendTransaction(txOptions)
  },
  async estimateGasAsync(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<number> {
    const self = this as CivilTokenControllerContract;
    const estimateGas = self.instance.methods.removeFromUnlocked(operator,
).estimateGas

    try {
      const estimate = Math.floor(await estimateGas(txData) * self.configuration.estimationMultiplier);
      debug("removeFromUnlocked: Gas estimation:", estimate);
      return estimate;
    } catch (e) {
      debug("removeFromUnlocked: Gas estimation failed, only sensible error is EVM error", e);
      throw new Error(CivilErrors.EvmException);
    }
  },
  async getRaw(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<TransactionConfig> {
      const self = this as CivilTokenControllerContract;
      const options: TransactionConfig = {... txData};
      if (!isDefined(options.gas)) {
        options.gas = await self.removeFromUnlocked.estimateGasAsync(
      operator,
      options,
      );
      }
      options.data = self.instance.methods.removeFromUnlocked(operator,
).encodeABI();
      return options;
  },
};
public newsroomMultisigList = {
  async callAsync(  index_0: string,
 ): Promise<boolean> {
    const self = this as CivilTokenControllerContract;
    return self.instance.methods.newsroomMultisigList(index_0,
).call();
  }
}
public addManager = {
  async sendTransactionAsync(
    managerAddress: string,
    txData?: TransactionConfig,
  ): Promise<TxHash> {
    const self = this as CivilTokenControllerContract;
    const txOptions: TransactionConfig = { ...self.configuration.txDefaults, ...txData };
    debug(`addManager(managerAddress: string,
)`);
    debug("addManager: txOptions:", txOptions);
    debug("addManager: Sending with:",  managerAddress,
  );
    txOptions.to = self.instance.options.address;
    txOptions.data = self.instance.methods.addManager(managerAddress,
).encodeABI();

    if (!isDefined(txOptions.gas)) {
      txOptions.gas = await self.ethApi.estimateGas(txOptions);
    }
    if (!isDefined(txOptions.gasPrice)) {
      const gasPricePromise = self.ethApi.getGasPriceString()
      txOptions.gasPrice = (await gasPricePromise).toString(); 
      debug("addManager: new gas price: ", txOptions.gasPrice);
    }

    return self.ethApi.sendTransaction(txOptions)
  },
  async estimateGasAsync(
    managerAddress: string,
    txData?: TransactionConfig,
  ): Promise<number> {
    const self = this as CivilTokenControllerContract;
    const estimateGas = self.instance.methods.addManager(managerAddress,
).estimateGas

    try {
      const estimate = Math.floor(await estimateGas(txData) * self.configuration.estimationMultiplier);
      debug("addManager: Gas estimation:", estimate);
      return estimate;
    } catch (e) {
      debug("addManager: Gas estimation failed, only sensible error is EVM error", e);
      throw new Error(CivilErrors.EvmException);
    }
  },
  async getRaw(
    managerAddress: string,
    txData?: TransactionConfig,
  ): Promise<TransactionConfig> {
      const self = this as CivilTokenControllerContract;
      const options: TransactionConfig = {... txData};
      if (!isDefined(options.gas)) {
        options.gas = await self.addManager.estimateGasAsync(
      managerAddress,
      options,
      );
      }
      options.data = self.instance.methods.addManager(managerAddress,
).encodeABI();
      return options;
  },
};
public removeFromCore = {
  async sendTransactionAsync(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<TxHash> {
    const self = this as CivilTokenControllerContract;
    const txOptions: TransactionConfig = { ...self.configuration.txDefaults, ...txData };
    debug(`removeFromCore(operator: string,
)`);
    debug("removeFromCore: txOptions:", txOptions);
    debug("removeFromCore: Sending with:",  operator,
  );
    txOptions.to = self.instance.options.address;
    txOptions.data = self.instance.methods.removeFromCore(operator,
).encodeABI();

    if (!isDefined(txOptions.gas)) {
      txOptions.gas = await self.ethApi.estimateGas(txOptions);
    }
    if (!isDefined(txOptions.gasPrice)) {
      const gasPricePromise = self.ethApi.getGasPriceString()
      txOptions.gasPrice = (await gasPricePromise).toString(); 
      debug("removeFromCore: new gas price: ", txOptions.gasPrice);
    }

    return self.ethApi.sendTransaction(txOptions)
  },
  async estimateGasAsync(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<number> {
    const self = this as CivilTokenControllerContract;
    const estimateGas = self.instance.methods.removeFromCore(operator,
).estimateGas

    try {
      const estimate = Math.floor(await estimateGas(txData) * self.configuration.estimationMultiplier);
      debug("removeFromCore: Gas estimation:", estimate);
      return estimate;
    } catch (e) {
      debug("removeFromCore: Gas estimation failed, only sensible error is EVM error", e);
      throw new Error(CivilErrors.EvmException);
    }
  },
  async getRaw(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<TransactionConfig> {
      const self = this as CivilTokenControllerContract;
      const options: TransactionConfig = {... txData};
      if (!isDefined(options.gas)) {
        options.gas = await self.removeFromCore.estimateGasAsync(
      operator,
      options,
      );
      }
      options.data = self.instance.methods.removeFromCore(operator,
).encodeABI();
      return options;
  },
};
public addToUnlocked = {
  async sendTransactionAsync(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<TxHash> {
    const self = this as CivilTokenControllerContract;
    const txOptions: TransactionConfig = { ...self.configuration.txDefaults, ...txData };
    debug(`addToUnlocked(operator: string,
)`);
    debug("addToUnlocked: txOptions:", txOptions);
    debug("addToUnlocked: Sending with:",  operator,
  );
    txOptions.to = self.instance.options.address;
    txOptions.data = self.instance.methods.addToUnlocked(operator,
).encodeABI();

    if (!isDefined(txOptions.gas)) {
      txOptions.gas = await self.ethApi.estimateGas(txOptions);
    }
    if (!isDefined(txOptions.gasPrice)) {
      const gasPricePromise = self.ethApi.getGasPriceString()
      txOptions.gasPrice = (await gasPricePromise).toString(); 
      debug("addToUnlocked: new gas price: ", txOptions.gasPrice);
    }

    return self.ethApi.sendTransaction(txOptions)
  },
  async estimateGasAsync(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<number> {
    const self = this as CivilTokenControllerContract;
    const estimateGas = self.instance.methods.addToUnlocked(operator,
).estimateGas

    try {
      const estimate = Math.floor(await estimateGas(txData) * self.configuration.estimationMultiplier);
      debug("addToUnlocked: Gas estimation:", estimate);
      return estimate;
    } catch (e) {
      debug("addToUnlocked: Gas estimation failed, only sensible error is EVM error", e);
      throw new Error(CivilErrors.EvmException);
    }
  },
  async getRaw(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<TransactionConfig> {
      const self = this as CivilTokenControllerContract;
      const options: TransactionConfig = {... txData};
      if (!isDefined(options.gas)) {
        options.gas = await self.addToUnlocked.estimateGasAsync(
      operator,
      options,
      );
      }
      options.data = self.instance.methods.addToUnlocked(operator,
).encodeABI();
      return options;
  },
};
public MUST_BE_A_CIVILIAN_CODE = {
  async callAsync(   ): Promise<BigNumber> {
    const self = this as CivilTokenControllerContract;
    return self.instance.methods.MUST_BE_A_CIVILIAN_CODE().call();
  }
}
public removeFromVerified = {
  async sendTransactionAsync(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<TxHash> {
    const self = this as CivilTokenControllerContract;
    const txOptions: TransactionConfig = { ...self.configuration.txDefaults, ...txData };
    debug(`removeFromVerified(operator: string,
)`);
    debug("removeFromVerified: txOptions:", txOptions);
    debug("removeFromVerified: Sending with:",  operator,
  );
    txOptions.to = self.instance.options.address;
    txOptions.data = self.instance.methods.removeFromVerified(operator,
).encodeABI();

    if (!isDefined(txOptions.gas)) {
      txOptions.gas = await self.ethApi.estimateGas(txOptions);
    }
    if (!isDefined(txOptions.gasPrice)) {
      const gasPricePromise = self.ethApi.getGasPriceString()
      txOptions.gasPrice = (await gasPricePromise).toString(); 
      debug("removeFromVerified: new gas price: ", txOptions.gasPrice);
    }

    return self.ethApi.sendTransaction(txOptions)
  },
  async estimateGasAsync(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<number> {
    const self = this as CivilTokenControllerContract;
    const estimateGas = self.instance.methods.removeFromVerified(operator,
).estimateGas

    try {
      const estimate = Math.floor(await estimateGas(txData) * self.configuration.estimationMultiplier);
      debug("removeFromVerified: Gas estimation:", estimate);
      return estimate;
    } catch (e) {
      debug("removeFromVerified: Gas estimation failed, only sensible error is EVM error", e);
      throw new Error(CivilErrors.EvmException);
    }
  },
  async getRaw(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<TransactionConfig> {
      const self = this as CivilTokenControllerContract;
      const options: TransactionConfig = {... txData};
      if (!isDefined(options.gas)) {
        options.gas = await self.removeFromVerified.estimateGasAsync(
      operator,
      options,
      );
      }
      options.data = self.instance.methods.removeFromVerified(operator,
).encodeABI();
      return options;
  },
};
public addToNewsroomMultisigs = {
  async sendTransactionAsync(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<TxHash> {
    const self = this as CivilTokenControllerContract;
    const txOptions: TransactionConfig = { ...self.configuration.txDefaults, ...txData };
    debug(`addToNewsroomMultisigs(operator: string,
)`);
    debug("addToNewsroomMultisigs: txOptions:", txOptions);
    debug("addToNewsroomMultisigs: Sending with:",  operator,
  );
    txOptions.to = self.instance.options.address;
    txOptions.data = self.instance.methods.addToNewsroomMultisigs(operator,
).encodeABI();

    if (!isDefined(txOptions.gas)) {
      txOptions.gas = await self.ethApi.estimateGas(txOptions);
    }
    if (!isDefined(txOptions.gasPrice)) {
      const gasPricePromise = self.ethApi.getGasPriceString()
      txOptions.gasPrice = (await gasPricePromise).toString(); 
      debug("addToNewsroomMultisigs: new gas price: ", txOptions.gasPrice);
    }

    return self.ethApi.sendTransaction(txOptions)
  },
  async estimateGasAsync(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<number> {
    const self = this as CivilTokenControllerContract;
    const estimateGas = self.instance.methods.addToNewsroomMultisigs(operator,
).estimateGas

    try {
      const estimate = Math.floor(await estimateGas(txData) * self.configuration.estimationMultiplier);
      debug("addToNewsroomMultisigs: Gas estimation:", estimate);
      return estimate;
    } catch (e) {
      debug("addToNewsroomMultisigs: Gas estimation failed, only sensible error is EVM error", e);
      throw new Error(CivilErrors.EvmException);
    }
  },
  async getRaw(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<TransactionConfig> {
      const self = this as CivilTokenControllerContract;
      const options: TransactionConfig = {... txData};
      if (!isDefined(options.gas)) {
        options.gas = await self.addToNewsroomMultisigs.estimateGasAsync(
      operator,
      options,
      );
      }
      options.data = self.instance.methods.addToNewsroomMultisigs(operator,
).encodeABI();
      return options;
  },
};
public renounceOwnership = {
  async sendTransactionAsync(
    txData?: TransactionConfig,
  ): Promise<TxHash> {
    const self = this as CivilTokenControllerContract;
    const txOptions: TransactionConfig = { ...self.configuration.txDefaults, ...txData };
    debug(`renounceOwnership()`);
    debug("renounceOwnership: txOptions:", txOptions);
    debug("renounceOwnership: Sending with:",    );
    txOptions.to = self.instance.options.address;
    txOptions.data = self.instance.methods.renounceOwnership().encodeABI();

    if (!isDefined(txOptions.gas)) {
      txOptions.gas = await self.ethApi.estimateGas(txOptions);
    }
    if (!isDefined(txOptions.gasPrice)) {
      const gasPricePromise = self.ethApi.getGasPriceString()
      txOptions.gasPrice = (await gasPricePromise).toString(); 
      debug("renounceOwnership: new gas price: ", txOptions.gasPrice);
    }

    return self.ethApi.sendTransaction(txOptions)
  },
  async estimateGasAsync(
    txData?: TransactionConfig,
  ): Promise<number> {
    const self = this as CivilTokenControllerContract;
    const estimateGas = self.instance.methods.renounceOwnership().estimateGas

    try {
      const estimate = Math.floor(await estimateGas(txData) * self.configuration.estimationMultiplier);
      debug("renounceOwnership: Gas estimation:", estimate);
      return estimate;
    } catch (e) {
      debug("renounceOwnership: Gas estimation failed, only sensible error is EVM error", e);
      throw new Error(CivilErrors.EvmException);
    }
  },
  async getRaw(
    txData?: TransactionConfig,
  ): Promise<TransactionConfig> {
      const self = this as CivilTokenControllerContract;
      const options: TransactionConfig = {... txData};
      if (!isDefined(options.gas)) {
        options.gas = await self.renounceOwnership.estimateGasAsync(
      options,
      );
      }
      options.data = self.instance.methods.renounceOwnership().encodeABI();
      return options;
  },
};
public addToCore = {
  async sendTransactionAsync(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<TxHash> {
    const self = this as CivilTokenControllerContract;
    const txOptions: TransactionConfig = { ...self.configuration.txDefaults, ...txData };
    debug(`addToCore(operator: string,
)`);
    debug("addToCore: txOptions:", txOptions);
    debug("addToCore: Sending with:",  operator,
  );
    txOptions.to = self.instance.options.address;
    txOptions.data = self.instance.methods.addToCore(operator,
).encodeABI();

    if (!isDefined(txOptions.gas)) {
      txOptions.gas = await self.ethApi.estimateGas(txOptions);
    }
    if (!isDefined(txOptions.gasPrice)) {
      const gasPricePromise = self.ethApi.getGasPriceString()
      txOptions.gasPrice = (await gasPricePromise).toString(); 
      debug("addToCore: new gas price: ", txOptions.gasPrice);
    }

    return self.ethApi.sendTransaction(txOptions)
  },
  async estimateGasAsync(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<number> {
    const self = this as CivilTokenControllerContract;
    const estimateGas = self.instance.methods.addToCore(operator,
).estimateGas

    try {
      const estimate = Math.floor(await estimateGas(txData) * self.configuration.estimationMultiplier);
      debug("addToCore: Gas estimation:", estimate);
      return estimate;
    } catch (e) {
      debug("addToCore: Gas estimation failed, only sensible error is EVM error", e);
      throw new Error(CivilErrors.EvmException);
    }
  },
  async getRaw(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<TransactionConfig> {
      const self = this as CivilTokenControllerContract;
      const options: TransactionConfig = {... txData};
      if (!isDefined(options.gas)) {
        options.gas = await self.addToCore.estimateGasAsync(
      operator,
      options,
      );
      }
      options.data = self.instance.methods.addToCore(operator,
).encodeABI();
      return options;
  },
};
public MUST_BE_A_CIVILIAN_ERROR = {
  async callAsync(   ): Promise<string> {
    const self = this as CivilTokenControllerContract;
    return self.instance.methods.MUST_BE_A_CIVILIAN_ERROR().call();
  }
}
public verifiedList = {
  async callAsync(  index_0: string,
 ): Promise<boolean> {
    const self = this as CivilTokenControllerContract;
    return self.instance.methods.verifiedList(index_0,
).call();
  }
}
public unlockedList = {
  async callAsync(  index_0: string,
 ): Promise<boolean> {
    const self = this as CivilTokenControllerContract;
    return self.instance.methods.unlockedList(index_0,
).call();
  }
}
public owner = {
  async callAsync(   ): Promise<string> {
    const self = this as CivilTokenControllerContract;
    return self.instance.methods.owner().call();
  }
}
public coreList = {
  async callAsync(  index_0: string,
 ): Promise<boolean> {
    const self = this as CivilTokenControllerContract;
    return self.instance.methods.coreList(index_0,
).call();
  }
}
public removeFromCivilians = {
  async sendTransactionAsync(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<TxHash> {
    const self = this as CivilTokenControllerContract;
    const txOptions: TransactionConfig = { ...self.configuration.txDefaults, ...txData };
    debug(`removeFromCivilians(operator: string,
)`);
    debug("removeFromCivilians: txOptions:", txOptions);
    debug("removeFromCivilians: Sending with:",  operator,
  );
    txOptions.to = self.instance.options.address;
    txOptions.data = self.instance.methods.removeFromCivilians(operator,
).encodeABI();

    if (!isDefined(txOptions.gas)) {
      txOptions.gas = await self.ethApi.estimateGas(txOptions);
    }
    if (!isDefined(txOptions.gasPrice)) {
      const gasPricePromise = self.ethApi.getGasPriceString()
      txOptions.gasPrice = (await gasPricePromise).toString(); 
      debug("removeFromCivilians: new gas price: ", txOptions.gasPrice);
    }

    return self.ethApi.sendTransaction(txOptions)
  },
  async estimateGasAsync(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<number> {
    const self = this as CivilTokenControllerContract;
    const estimateGas = self.instance.methods.removeFromCivilians(operator,
).estimateGas

    try {
      const estimate = Math.floor(await estimateGas(txData) * self.configuration.estimationMultiplier);
      debug("removeFromCivilians: Gas estimation:", estimate);
      return estimate;
    } catch (e) {
      debug("removeFromCivilians: Gas estimation failed, only sensible error is EVM error", e);
      throw new Error(CivilErrors.EvmException);
    }
  },
  async getRaw(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<TransactionConfig> {
      const self = this as CivilTokenControllerContract;
      const options: TransactionConfig = {... txData};
      if (!isDefined(options.gas)) {
        options.gas = await self.removeFromCivilians.estimateGasAsync(
      operator,
      options,
      );
      }
      options.data = self.instance.methods.removeFromCivilians(operator,
).encodeABI();
      return options;
  },
};
public removeManager = {
  async sendTransactionAsync(
    managerAddress: string,
    txData?: TransactionConfig,
  ): Promise<TxHash> {
    const self = this as CivilTokenControllerContract;
    const txOptions: TransactionConfig = { ...self.configuration.txDefaults, ...txData };
    debug(`removeManager(managerAddress: string,
)`);
    debug("removeManager: txOptions:", txOptions);
    debug("removeManager: Sending with:",  managerAddress,
  );
    txOptions.to = self.instance.options.address;
    txOptions.data = self.instance.methods.removeManager(managerAddress,
).encodeABI();

    if (!isDefined(txOptions.gas)) {
      txOptions.gas = await self.ethApi.estimateGas(txOptions);
    }
    if (!isDefined(txOptions.gasPrice)) {
      const gasPricePromise = self.ethApi.getGasPriceString()
      txOptions.gasPrice = (await gasPricePromise).toString(); 
      debug("removeManager: new gas price: ", txOptions.gasPrice);
    }

    return self.ethApi.sendTransaction(txOptions)
  },
  async estimateGasAsync(
    managerAddress: string,
    txData?: TransactionConfig,
  ): Promise<number> {
    const self = this as CivilTokenControllerContract;
    const estimateGas = self.instance.methods.removeManager(managerAddress,
).estimateGas

    try {
      const estimate = Math.floor(await estimateGas(txData) * self.configuration.estimationMultiplier);
      debug("removeManager: Gas estimation:", estimate);
      return estimate;
    } catch (e) {
      debug("removeManager: Gas estimation failed, only sensible error is EVM error", e);
      throw new Error(CivilErrors.EvmException);
    }
  },
  async getRaw(
    managerAddress: string,
    txData?: TransactionConfig,
  ): Promise<TransactionConfig> {
      const self = this as CivilTokenControllerContract;
      const options: TransactionConfig = {... txData};
      if (!isDefined(options.gas)) {
        options.gas = await self.removeManager.estimateGasAsync(
      managerAddress,
      options,
      );
      }
      options.data = self.instance.methods.removeManager(managerAddress,
).encodeABI();
      return options;
  },
};
public addToStorefront = {
  async sendTransactionAsync(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<TxHash> {
    const self = this as CivilTokenControllerContract;
    const txOptions: TransactionConfig = { ...self.configuration.txDefaults, ...txData };
    debug(`addToStorefront(operator: string,
)`);
    debug("addToStorefront: txOptions:", txOptions);
    debug("addToStorefront: Sending with:",  operator,
  );
    txOptions.to = self.instance.options.address;
    txOptions.data = self.instance.methods.addToStorefront(operator,
).encodeABI();

    if (!isDefined(txOptions.gas)) {
      txOptions.gas = await self.ethApi.estimateGas(txOptions);
    }
    if (!isDefined(txOptions.gasPrice)) {
      const gasPricePromise = self.ethApi.getGasPriceString()
      txOptions.gasPrice = (await gasPricePromise).toString(); 
      debug("addToStorefront: new gas price: ", txOptions.gasPrice);
    }

    return self.ethApi.sendTransaction(txOptions)
  },
  async estimateGasAsync(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<number> {
    const self = this as CivilTokenControllerContract;
    const estimateGas = self.instance.methods.addToStorefront(operator,
).estimateGas

    try {
      const estimate = Math.floor(await estimateGas(txData) * self.configuration.estimationMultiplier);
      debug("addToStorefront: Gas estimation:", estimate);
      return estimate;
    } catch (e) {
      debug("addToStorefront: Gas estimation failed, only sensible error is EVM error", e);
      throw new Error(CivilErrors.EvmException);
    }
  },
  async getRaw(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<TransactionConfig> {
      const self = this as CivilTokenControllerContract;
      const options: TransactionConfig = {... txData};
      if (!isDefined(options.gas)) {
        options.gas = await self.addToStorefront.estimateGasAsync(
      operator,
      options,
      );
      }
      options.data = self.instance.methods.addToStorefront(operator,
).encodeABI();
      return options;
  },
};
public removeFromStorefront = {
  async sendTransactionAsync(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<TxHash> {
    const self = this as CivilTokenControllerContract;
    const txOptions: TransactionConfig = { ...self.configuration.txDefaults, ...txData };
    debug(`removeFromStorefront(operator: string,
)`);
    debug("removeFromStorefront: txOptions:", txOptions);
    debug("removeFromStorefront: Sending with:",  operator,
  );
    txOptions.to = self.instance.options.address;
    txOptions.data = self.instance.methods.removeFromStorefront(operator,
).encodeABI();

    if (!isDefined(txOptions.gas)) {
      txOptions.gas = await self.ethApi.estimateGas(txOptions);
    }
    if (!isDefined(txOptions.gasPrice)) {
      const gasPricePromise = self.ethApi.getGasPriceString()
      txOptions.gasPrice = (await gasPricePromise).toString(); 
      debug("removeFromStorefront: new gas price: ", txOptions.gasPrice);
    }

    return self.ethApi.sendTransaction(txOptions)
  },
  async estimateGasAsync(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<number> {
    const self = this as CivilTokenControllerContract;
    const estimateGas = self.instance.methods.removeFromStorefront(operator,
).estimateGas

    try {
      const estimate = Math.floor(await estimateGas(txData) * self.configuration.estimationMultiplier);
      debug("removeFromStorefront: Gas estimation:", estimate);
      return estimate;
    } catch (e) {
      debug("removeFromStorefront: Gas estimation failed, only sensible error is EVM error", e);
      throw new Error(CivilErrors.EvmException);
    }
  },
  async getRaw(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<TransactionConfig> {
      const self = this as CivilTokenControllerContract;
      const options: TransactionConfig = {... txData};
      if (!isDefined(options.gas)) {
        options.gas = await self.removeFromStorefront.estimateGasAsync(
      operator,
      options,
      );
      }
      options.data = self.instance.methods.removeFromStorefront(operator,
).encodeABI();
      return options;
  },
};
public MUST_BE_VERIFIED_ERROR = {
  async callAsync(   ): Promise<string> {
    const self = this as CivilTokenControllerContract;
    return self.instance.methods.MUST_BE_VERIFIED_ERROR().call();
  }
}
public MUST_BE_VERIFIED_CODE = {
  async callAsync(   ): Promise<BigNumber> {
    const self = this as CivilTokenControllerContract;
    return self.instance.methods.MUST_BE_VERIFIED_CODE().call();
  }
}
public isManager = {
  async callAsync(   ): Promise<boolean> {
    const self = this as CivilTokenControllerContract;
    return self.instance.methods.isManager().call();
  }
}
public MUST_BE_UNLOCKED_CODE = {
  async callAsync(   ): Promise<BigNumber> {
    const self = this as CivilTokenControllerContract;
    return self.instance.methods.MUST_BE_UNLOCKED_CODE().call();
  }
}
public SUCCESS_MESSAGE = {
  async callAsync(   ): Promise<string> {
    const self = this as CivilTokenControllerContract;
    return self.instance.methods.SUCCESS_MESSAGE().call();
  }
}
public removeFromNewsroomMultisigs = {
  async sendTransactionAsync(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<TxHash> {
    const self = this as CivilTokenControllerContract;
    const txOptions: TransactionConfig = { ...self.configuration.txDefaults, ...txData };
    debug(`removeFromNewsroomMultisigs(operator: string,
)`);
    debug("removeFromNewsroomMultisigs: txOptions:", txOptions);
    debug("removeFromNewsroomMultisigs: Sending with:",  operator,
  );
    txOptions.to = self.instance.options.address;
    txOptions.data = self.instance.methods.removeFromNewsroomMultisigs(operator,
).encodeABI();

    if (!isDefined(txOptions.gas)) {
      txOptions.gas = await self.ethApi.estimateGas(txOptions);
    }
    if (!isDefined(txOptions.gasPrice)) {
      const gasPricePromise = self.ethApi.getGasPriceString()
      txOptions.gasPrice = (await gasPricePromise).toString(); 
      debug("removeFromNewsroomMultisigs: new gas price: ", txOptions.gasPrice);
    }

    return self.ethApi.sendTransaction(txOptions)
  },
  async estimateGasAsync(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<number> {
    const self = this as CivilTokenControllerContract;
    const estimateGas = self.instance.methods.removeFromNewsroomMultisigs(operator,
).estimateGas

    try {
      const estimate = Math.floor(await estimateGas(txData) * self.configuration.estimationMultiplier);
      debug("removeFromNewsroomMultisigs: Gas estimation:", estimate);
      return estimate;
    } catch (e) {
      debug("removeFromNewsroomMultisigs: Gas estimation failed, only sensible error is EVM error", e);
      throw new Error(CivilErrors.EvmException);
    }
  },
  async getRaw(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<TransactionConfig> {
      const self = this as CivilTokenControllerContract;
      const options: TransactionConfig = {... txData};
      if (!isDefined(options.gas)) {
        options.gas = await self.removeFromNewsroomMultisigs.estimateGasAsync(
      operator,
      options,
      );
      }
      options.data = self.instance.methods.removeFromNewsroomMultisigs(operator,
).encodeABI();
      return options;
  },
};
public checkProofOfUse = {
  async sendTransactionAsync(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<TxHash> {
    const self = this as CivilTokenControllerContract;
    const txOptions: TransactionConfig = { ...self.configuration.txDefaults, ...txData };
    debug(`checkProofOfUse(operator: string,
)`);
    debug("checkProofOfUse: txOptions:", txOptions);
    debug("checkProofOfUse: Sending with:",  operator,
  );
    txOptions.to = self.instance.options.address;
    txOptions.data = self.instance.methods.checkProofOfUse(operator,
).encodeABI();

    if (!isDefined(txOptions.gas)) {
      txOptions.gas = await self.ethApi.estimateGas(txOptions);
    }
    if (!isDefined(txOptions.gasPrice)) {
      const gasPricePromise = self.ethApi.getGasPriceString()
      txOptions.gasPrice = (await gasPricePromise).toString(); 
      debug("checkProofOfUse: new gas price: ", txOptions.gasPrice);
    }

    return self.ethApi.sendTransaction(txOptions)
  },
  async estimateGasAsync(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<number> {
    const self = this as CivilTokenControllerContract;
    const estimateGas = self.instance.methods.checkProofOfUse(operator,
).estimateGas

    try {
      const estimate = Math.floor(await estimateGas(txData) * self.configuration.estimationMultiplier);
      debug("checkProofOfUse: Gas estimation:", estimate);
      return estimate;
    } catch (e) {
      debug("checkProofOfUse: Gas estimation failed, only sensible error is EVM error", e);
      throw new Error(CivilErrors.EvmException);
    }
  },
  async getRaw(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<TransactionConfig> {
      const self = this as CivilTokenControllerContract;
      const options: TransactionConfig = {... txData};
      if (!isDefined(options.gas)) {
        options.gas = await self.checkProofOfUse.estimateGasAsync(
      operator,
      options,
      );
      }
      options.data = self.instance.methods.checkProofOfUse(operator,
).encodeABI();
      return options;
  },
};
public addToVerified = {
  async sendTransactionAsync(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<TxHash> {
    const self = this as CivilTokenControllerContract;
    const txOptions: TransactionConfig = { ...self.configuration.txDefaults, ...txData };
    debug(`addToVerified(operator: string,
)`);
    debug("addToVerified: txOptions:", txOptions);
    debug("addToVerified: Sending with:",  operator,
  );
    txOptions.to = self.instance.options.address;
    txOptions.data = self.instance.methods.addToVerified(operator,
).encodeABI();

    if (!isDefined(txOptions.gas)) {
      txOptions.gas = await self.ethApi.estimateGas(txOptions);
    }
    if (!isDefined(txOptions.gasPrice)) {
      const gasPricePromise = self.ethApi.getGasPriceString()
      txOptions.gasPrice = (await gasPricePromise).toString(); 
      debug("addToVerified: new gas price: ", txOptions.gasPrice);
    }

    return self.ethApi.sendTransaction(txOptions)
  },
  async estimateGasAsync(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<number> {
    const self = this as CivilTokenControllerContract;
    const estimateGas = self.instance.methods.addToVerified(operator,
).estimateGas

    try {
      const estimate = Math.floor(await estimateGas(txData) * self.configuration.estimationMultiplier);
      debug("addToVerified: Gas estimation:", estimate);
      return estimate;
    } catch (e) {
      debug("addToVerified: Gas estimation failed, only sensible error is EVM error", e);
      throw new Error(CivilErrors.EvmException);
    }
  },
  async getRaw(
    operator: string,
    txData?: TransactionConfig,
  ): Promise<TransactionConfig> {
      const self = this as CivilTokenControllerContract;
      const options: TransactionConfig = {... txData};
      if (!isDefined(options.gas)) {
        options.gas = await self.addToVerified.estimateGasAsync(
      operator,
      options,
      );
      }
      options.data = self.instance.methods.addToVerified(operator,
).encodeABI();
      return options;
  },
};
public civilianList = {
  async callAsync(  index_0: string,
 ): Promise<boolean> {
    const self = this as CivilTokenControllerContract;
    return self.instance.methods.civilianList(index_0,
).call();
  }
}
public storefrontList = {
  async callAsync(  index_0: string,
 ): Promise<boolean> {
    const self = this as CivilTokenControllerContract;
    return self.instance.methods.storefrontList(index_0,
).call();
  }
}
public MUST_BE_UNLOCKED_ERROR = {
  async callAsync(   ): Promise<string> {
    const self = this as CivilTokenControllerContract;
    return self.instance.methods.MUST_BE_UNLOCKED_ERROR().call();
  }
}
public checkManagerStatus = {
  async callAsync(  managerAddress: string,
 ): Promise<boolean> {
    const self = this as CivilTokenControllerContract;
    return self.instance.methods.checkManagerStatus(managerAddress,
).call();
  }
}
public transferOwnership = {
  async sendTransactionAsync(
    _newOwner: string,
    txData?: TransactionConfig,
  ): Promise<TxHash> {
    const self = this as CivilTokenControllerContract;
    const txOptions: TransactionConfig = { ...self.configuration.txDefaults, ...txData };
    debug(`transferOwnership(_newOwner: string,
)`);
    debug("transferOwnership: txOptions:", txOptions);
    debug("transferOwnership: Sending with:",  _newOwner,
  );
    txOptions.to = self.instance.options.address;
    txOptions.data = self.instance.methods.transferOwnership(_newOwner,
).encodeABI();

    if (!isDefined(txOptions.gas)) {
      txOptions.gas = await self.ethApi.estimateGas(txOptions);
    }
    if (!isDefined(txOptions.gasPrice)) {
      const gasPricePromise = self.ethApi.getGasPriceString()
      txOptions.gasPrice = (await gasPricePromise).toString(); 
      debug("transferOwnership: new gas price: ", txOptions.gasPrice);
    }

    return self.ethApi.sendTransaction(txOptions)
  },
  async estimateGasAsync(
    _newOwner: string,
    txData?: TransactionConfig,
  ): Promise<number> {
    const self = this as CivilTokenControllerContract;
    const estimateGas = self.instance.methods.transferOwnership(_newOwner,
).estimateGas

    try {
      const estimate = Math.floor(await estimateGas(txData) * self.configuration.estimationMultiplier);
      debug("transferOwnership: Gas estimation:", estimate);
      return estimate;
    } catch (e) {
      debug("transferOwnership: Gas estimation failed, only sensible error is EVM error", e);
      throw new Error(CivilErrors.EvmException);
    }
  },
  async getRaw(
    _newOwner: string,
    txData?: TransactionConfig,
  ): Promise<TransactionConfig> {
      const self = this as CivilTokenControllerContract;
      const options: TransactionConfig = {... txData};
      if (!isDefined(options.gas)) {
        options.gas = await self.transferOwnership.estimateGasAsync(
      _newOwner,
      options,
      );
      }
      options.data = self.instance.methods.transferOwnership(_newOwner,
).encodeABI();
      return options;
  },
};
public managers = {
  async callAsync(  index_0: string,
 ): Promise<boolean> {
    const self = this as CivilTokenControllerContract;
    return self.instance.methods.managers(index_0,
).call();
  }
}
public detectTransferRestriction = {
  async callAsync(  from: string,
to: string,
value: BigNumber,
 ): Promise<BigNumber> {
    const self = this as CivilTokenControllerContract;
    return self.instance.methods.detectTransferRestriction(from,
to,
value,
).call();
  }
}
public messageForTransferRestriction = {
  async callAsync(  restrictionCode: number|BigNumber,
 ): Promise<string> {
    const self = this as CivilTokenControllerContract;
    return self.instance.methods.messageForTransferRestriction(restrictionCode,
).call();
  }
}
public onRequestVotingRights = {
  async sendTransactionAsync(
    user: string,
    tokenAmount: BigNumber,
    txData?: TransactionConfig,
  ): Promise<TxHash> {
    const self = this as CivilTokenControllerContract;
    const txOptions: TransactionConfig = { ...self.configuration.txDefaults, ...txData };
    debug(`onRequestVotingRights(user: string,
tokenAmount: BigNumber,
)`);
    debug("onRequestVotingRights: txOptions:", txOptions);
    debug("onRequestVotingRights: Sending with:",  user,
tokenAmount,
  );
    txOptions.to = self.instance.options.address;
    txOptions.data = self.instance.methods.onRequestVotingRights(user,
tokenAmount,
).encodeABI();

    if (!isDefined(txOptions.gas)) {
      txOptions.gas = await self.ethApi.estimateGas(txOptions);
    }
    if (!isDefined(txOptions.gasPrice)) {
      const gasPricePromise = self.ethApi.getGasPriceString()
      txOptions.gasPrice = (await gasPricePromise).toString(); 
      debug("onRequestVotingRights: new gas price: ", txOptions.gasPrice);
    }

    return self.ethApi.sendTransaction(txOptions)
  },
  async estimateGasAsync(
    user: string,
    tokenAmount: BigNumber,
    txData?: TransactionConfig,
  ): Promise<number> {
    const self = this as CivilTokenControllerContract;
    const estimateGas = self.instance.methods.onRequestVotingRights(user,
tokenAmount,
).estimateGas

    try {
      const estimate = Math.floor(await estimateGas(txData) * self.configuration.estimationMultiplier);
      debug("onRequestVotingRights: Gas estimation:", estimate);
      return estimate;
    } catch (e) {
      debug("onRequestVotingRights: Gas estimation failed, only sensible error is EVM error", e);
      throw new Error(CivilErrors.EvmException);
    }
  },
  async getRaw(
    user: string,
    tokenAmount: BigNumber,
    txData?: TransactionConfig,
  ): Promise<TransactionConfig> {
      const self = this as CivilTokenControllerContract;
      const options: TransactionConfig = {... txData};
      if (!isDefined(options.gas)) {
        options.gas = await self.onRequestVotingRights.estimateGasAsync(
      user,
      tokenAmount,
      options,
      );
      }
      options.data = self.instance.methods.onRequestVotingRights(user,
tokenAmount,
).encodeABI();
      return options;
  },
};
public OwnershipRenouncedStream = streamifyEvent<CivilTokenController.Args.OwnershipRenounced, CivilTokenController.LogEvents.OwnershipRenounced>
    (this.instance, "OwnershipRenounced");
public OwnershipTransferredStream = streamifyEvent<CivilTokenController.Args.OwnershipTransferred, CivilTokenController.LogEvents.OwnershipTransferred>
    (this.instance, "OwnershipTransferred");
// tslint:enable:variable-name

private constructor(instance: Contract, ethApi: EthApi) {
super(instance, ethApi);
// Call methods access this instance while being in a sub-object, we're rebinding what
// "this" means for everything in this class, this also requires "noImplicitThis" to be false
bindNestedAll(this, ["constructor", "instance", "defaults", "ethApi"]);
}
// tslint:enable:member-ordering
}

// tslint:disable:no-namespace
export namespace CivilTokenController {
  export enum Events {
    OwnershipRenounced = "OwnershipRenounced",
    OwnershipTransferred = "OwnershipTransferred",
  }

  // tslint:disable:class-name
  export namespace Args {
    export interface OwnershipRenounced {
      previousOwner: string;
    }
    export interface OwnershipTransferred {
      previousOwner: string;
      newOwner: string;
    }
  }
  // tslint:enable:class-name

  export namespace Logs {
    export type OwnershipRenounced = DecodedLogEntry<Args.OwnershipRenounced, Events.OwnershipRenounced>;
    export type OwnershipTransferred = DecodedLogEntry<Args.OwnershipTransferred, Events.OwnershipTransferred>;

    export type All =
      Logs.OwnershipRenounced |
      Logs.OwnershipTransferred;
  }

  export namespace LogEvents {
    export type OwnershipRenounced = DecodedLogEntryEvent<Args.OwnershipRenounced, Events.OwnershipRenounced>;
    export type OwnershipTransferred = DecodedLogEntryEvent<Args.OwnershipTransferred, Events.OwnershipTransferred>;

    export type All =
      LogEvents.OwnershipRenounced |
      LogEvents.OwnershipTransferred;
  }

  export type Receipt = DecodedTransactionReceipt<Logs.All>;
  export type EventReceipt = DecodedTransactionReceipt<LogEvents.All>;
}
// tslint:enable:no-namespace