generated.ts

// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.

import {
  ethereum,
  JSONValue,
  TypedMap,
  Entity,
  Bytes,
  Address,
  BigInt
} from "@graphprotocol/graph-ts";

export class Challenged extends ethereum.Event {
  get params(): Challenged__Params {
    return new Challenged__Params(this);
  }
}

export class Challenged__Params {
  _event: Challenged;

  constructor(event: Challenged) {
    this._event = event;
  }

  get containerHash(): Bytes {
    return this._event.parameters[0].value.toBytes();
  }

  get actor(): Address {
    return this._event.parameters[1].value.toAddress();
  }

  get reason(): Bytes {
    return this._event.parameters[2].value.toBytes();
  }

  get resolverId(): BigInt {
    return this._event.parameters[3].value.toBigInt();
  }

  get collateral(): ChallengedCollateralStruct {
    return this._event.parameters[4].value.toTuple() as ChallengedCollateralStruct;
  }
}

export class ChallengedCollateralStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}

export class Configured extends ethereum.Event {
  get params(): Configured__Params {
    return new Configured__Params(this);
  }
}

export class Configured__Params {
  _event: Configured;

  constructor(event: Configured) {
    this._event = event;
  }

  get configHash(): Bytes {
    return this._event.parameters[0].value.toBytes();
  }

  get actor(): Address {
    return this._event.parameters[1].value.toAddress();
  }

  get config(): ConfiguredConfigStruct {
    return this._event.parameters[2].value.toTuple() as ConfiguredConfigStruct;
  }
}

export class ConfiguredConfigStruct extends ethereum.Tuple {
  get executionDelay(): BigInt {
    return this[0].toBigInt();
  }

  get scheduleDeposit(): ConfiguredConfigScheduleDepositStruct {
    return this[1].toTuple() as ConfiguredConfigScheduleDepositStruct;
  }

  get challengeDeposit(): ConfiguredConfigChallengeDepositStruct {
    return this[2].toTuple() as ConfiguredConfigChallengeDepositStruct;
  }

  get resolver(): Address {
    return this[3].toAddress();
  }

  get rules(): Bytes {
    return this[4].toBytes();
  }
}

export class ConfiguredConfigScheduleDepositStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}

export class ConfiguredConfigChallengeDepositStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}

export class Executed extends ethereum.Event {
  get params(): Executed__Params {
    return new Executed__Params(this);
  }
}

export class Executed__Params {
  _event: Executed;

  constructor(event: Executed) {
    this._event = event;
  }

  get containerHash(): Bytes {
    return this._event.parameters[0].value.toBytes();
  }

  get actor(): Address {
    return this._event.parameters[1].value.toAddress();
  }
}

export class Frozen extends ethereum.Event {
  get params(): Frozen__Params {
    return new Frozen__Params(this);
  }
}

export class Frozen__Params {
  _event: Frozen;

  constructor(event: Frozen) {
    this._event = event;
  }

  get role(): Bytes {
    return this._event.parameters[0].value.toBytes();
  }

  get actor(): Address {
    return this._event.parameters[1].value.toAddress();
  }
}

export class Granted extends ethereum.Event {
  get params(): Granted__Params {
    return new Granted__Params(this);
  }
}

export class Granted__Params {
  _event: Granted;

  constructor(event: Granted) {
    this._event = event;
  }

  get role(): Bytes {
    return this._event.parameters[0].value.toBytes();
  }

  get actor(): Address {
    return this._event.parameters[1].value.toAddress();
  }

  get who(): Address {
    return this._event.parameters[2].value.toAddress();
  }

  get oracle(): Address {
    return this._event.parameters[3].value.toAddress();
  }
}

export class Initialized extends ethereum.Event {
  get params(): Initialized__Params {
    return new Initialized__Params(this);
  }
}

export class Initialized__Params {
  _event: Initialized;

  constructor(event: Initialized) {
    this._event = event;
  }

  get key(): Bytes {
    return this._event.parameters[0].value.toBytes();
  }
}

export class ReceivedCallback extends ethereum.Event {
  get params(): ReceivedCallback__Params {
    return new ReceivedCallback__Params(this);
  }
}

export class ReceivedCallback__Params {
  _event: ReceivedCallback;

  constructor(event: ReceivedCallback) {
    this._event = event;
  }

  get sig(): Bytes {
    return this._event.parameters[0].value.toBytes();
  }

  get data(): Bytes {
    return this._event.parameters[1].value.toBytes();
  }
}

export class RegisteredCallback extends ethereum.Event {
  get params(): RegisteredCallback__Params {
    return new RegisteredCallback__Params(this);
  }
}

export class RegisteredCallback__Params {
  _event: RegisteredCallback;

  constructor(event: RegisteredCallback) {
    this._event = event;
  }

  get sig(): Bytes {
    return this._event.parameters[0].value.toBytes();
  }

  get magicNumber(): Bytes {
    return this._event.parameters[1].value.toBytes();
  }
}

export class RegisteredStandard extends ethereum.Event {
  get params(): RegisteredStandard__Params {
    return new RegisteredStandard__Params(this);
  }
}

export class RegisteredStandard__Params {
  _event: RegisteredStandard;

  constructor(event: RegisteredStandard) {
    this._event = event;
  }

  get interfaceId(): Bytes {
    return this._event.parameters[0].value.toBytes();
  }
}

export class Resolved extends ethereum.Event {
  get params(): Resolved__Params {
    return new Resolved__Params(this);
  }
}

export class Resolved__Params {
  _event: Resolved;

  constructor(event: Resolved) {
    this._event = event;
  }

  get containerHash(): Bytes {
    return this._event.parameters[0].value.toBytes();
  }

  get actor(): Address {
    return this._event.parameters[1].value.toAddress();
  }

  get approved(): boolean {
    return this._event.parameters[2].value.toBoolean();
  }
}

export class Revoked extends ethereum.Event {
  get params(): Revoked__Params {
    return new Revoked__Params(this);
  }
}

export class Revoked__Params {
  _event: Revoked;

  constructor(event: Revoked) {
    this._event = event;
  }

  get role(): Bytes {
    return this._event.parameters[0].value.toBytes();
  }

  get actor(): Address {
    return this._event.parameters[1].value.toAddress();
  }

  get who(): Address {
    return this._event.parameters[2].value.toAddress();
  }
}

export class Ruled extends ethereum.Event {
  get params(): Ruled__Params {
    return new Ruled__Params(this);
  }
}

export class Ruled__Params {
  _event: Ruled;

  constructor(event: Ruled) {
    this._event = event;
  }

  get arbitrator(): Address {
    return this._event.parameters[0].value.toAddress();
  }

  get disputeId(): BigInt {
    return this._event.parameters[1].value.toBigInt();
  }

  get ruling(): BigInt {
    return this._event.parameters[2].value.toBigInt();
  }
}

export class Scheduled extends ethereum.Event {
  get params(): Scheduled__Params {
    return new Scheduled__Params(this);
  }
}

export class Scheduled__Params {
  _event: Scheduled;

  constructor(event: Scheduled) {
    this._event = event;
  }

  get containerHash(): Bytes {
    return this._event.parameters[0].value.toBytes();
  }

  get payload(): ScheduledPayloadStruct {
    return this._event.parameters[1].value.toTuple() as ScheduledPayloadStruct;
  }
}

export class ScheduledPayloadStruct extends ethereum.Tuple {
  get nonce(): BigInt {
    return this[0].toBigInt();
  }

  get executionTime(): BigInt {
    return this[1].toBigInt();
  }

  get submitter(): Address {
    return this[2].toAddress();
  }

  get executor(): Address {
    return this[3].toAddress();
  }

  get actions(): Array<ScheduledPayloadActionsStruct> {
    return this[4].toTupleArray<ScheduledPayloadActionsStruct>();
  }

  get allowFailuresMap(): Bytes {
    return this[5].toBytes();
  }

  get proof(): Bytes {
    return this[6].toBytes();
  }
}

export class ScheduledPayloadActionsStruct extends ethereum.Tuple {
  get to(): Address {
    return this[0].toAddress();
  }

  get value(): BigInt {
    return this[1].toBigInt();
  }

  get data(): Bytes {
    return this[2].toBytes();
  }
}

export class Vetoed extends ethereum.Event {
  get params(): Vetoed__Params {
    return new Vetoed__Params(this);
  }
}

export class Vetoed__Params {
  _event: Vetoed;

  constructor(event: Vetoed) {
    this._event = event;
  }

  get containerHash(): Bytes {
    return this._event.parameters[0].value.toBytes();
  }

  get actor(): Address {
    return this._event.parameters[1].value.toAddress();
  }

  get reason(): Bytes {
    return this._event.parameters[2].value.toBytes();
  }
}

export class GovernQueue__challengeInput_containerStruct extends ethereum.Tuple {
  get payload(): GovernQueue__challengeInput_containerPayloadStruct {
    return this[0].toTuple() as GovernQueue__challengeInput_containerPayloadStruct;
  }

  get config(): GovernQueue__challengeInput_containerConfigStruct {
    return this[1].toTuple() as GovernQueue__challengeInput_containerConfigStruct;
  }
}

export class GovernQueue__challengeInput_containerPayloadStruct extends ethereum.Tuple {
  get nonce(): BigInt {
    return this[0].toBigInt();
  }

  get executionTime(): BigInt {
    return this[1].toBigInt();
  }

  get submitter(): Address {
    return this[2].toAddress();
  }

  get executor(): Address {
    return this[3].toAddress();
  }

  get actions(): Array<
    GovernQueue__challengeInput_containerPayloadActionsStruct
  > {
    return this[4].toTupleArray<
      GovernQueue__challengeInput_containerPayloadActionsStruct
    >();
  }

  get allowFailuresMap(): Bytes {
    return this[5].toBytes();
  }

  get proof(): Bytes {
    return this[6].toBytes();
  }
}

export class GovernQueue__challengeInput_containerPayloadActionsStruct extends ethereum.Tuple {
  get to(): Address {
    return this[0].toAddress();
  }

  get value(): BigInt {
    return this[1].toBigInt();
  }

  get data(): Bytes {
    return this[2].toBytes();
  }
}

export class GovernQueue__challengeInput_containerConfigStruct extends ethereum.Tuple {
  get executionDelay(): BigInt {
    return this[0].toBigInt();
  }

  get scheduleDeposit(): GovernQueue__challengeInput_containerConfigScheduleDepositStruct {
    return this[1].toTuple() as GovernQueue__challengeInput_containerConfigScheduleDepositStruct;
  }

  get challengeDeposit(): GovernQueue__challengeInput_containerConfigChallengeDepositStruct {
    return this[2].toTuple() as GovernQueue__challengeInput_containerConfigChallengeDepositStruct;
  }

  get resolver(): Address {
    return this[3].toAddress();
  }

  get rules(): Bytes {
    return this[4].toBytes();
  }
}

export class GovernQueue__challengeInput_containerConfigScheduleDepositStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}

export class GovernQueue__challengeInput_containerConfigChallengeDepositStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}

export class GovernQueue__configureInput_configStruct extends ethereum.Tuple {
  get executionDelay(): BigInt {
    return this[0].toBigInt();
  }

  get scheduleDeposit(): GovernQueue__configureInput_configScheduleDepositStruct {
    return this[1].toTuple() as GovernQueue__configureInput_configScheduleDepositStruct;
  }

  get challengeDeposit(): GovernQueue__configureInput_configChallengeDepositStruct {
    return this[2].toTuple() as GovernQueue__configureInput_configChallengeDepositStruct;
  }

  get resolver(): Address {
    return this[3].toAddress();
  }

  get rules(): Bytes {
    return this[4].toBytes();
  }
}

export class GovernQueue__configureInput_configScheduleDepositStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}

export class GovernQueue__configureInput_configChallengeDepositStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}

export class GovernQueue__executeResult {
  value0: Bytes;
  value1: Array<Bytes>;

  constructor(value0: Bytes, value1: Array<Bytes>) {
    this.value0 = value0;
    this.value1 = value1;
  }

  toMap(): TypedMap<string, ethereum.Value> {
    let map = new TypedMap<string, ethereum.Value>();
    map.set("value0", ethereum.Value.fromFixedBytes(this.value0));
    map.set("value1", ethereum.Value.fromBytesArray(this.value1));
    return map;
  }
}

export class GovernQueue__executeInput_containerStruct extends ethereum.Tuple {
  get payload(): GovernQueue__executeInput_containerPayloadStruct {
    return this[0].toTuple() as GovernQueue__executeInput_containerPayloadStruct;
  }

  get config(): GovernQueue__executeInput_containerConfigStruct {
    return this[1].toTuple() as GovernQueue__executeInput_containerConfigStruct;
  }
}

export class GovernQueue__executeInput_containerPayloadStruct extends ethereum.Tuple {
  get nonce(): BigInt {
    return this[0].toBigInt();
  }

  get executionTime(): BigInt {
    return this[1].toBigInt();
  }

  get submitter(): Address {
    return this[2].toAddress();
  }

  get executor(): Address {
    return this[3].toAddress();
  }

  get actions(): Array<
    GovernQueue__executeInput_containerPayloadActionsStruct
  > {
    return this[4].toTupleArray<
      GovernQueue__executeInput_containerPayloadActionsStruct
    >();
  }

  get allowFailuresMap(): Bytes {
    return this[5].toBytes();
  }

  get proof(): Bytes {
    return this[6].toBytes();
  }
}

export class GovernQueue__executeInput_containerPayloadActionsStruct extends ethereum.Tuple {
  get to(): Address {
    return this[0].toAddress();
  }

  get value(): BigInt {
    return this[1].toBigInt();
  }

  get data(): Bytes {
    return this[2].toBytes();
  }
}

export class GovernQueue__executeInput_containerConfigStruct extends ethereum.Tuple {
  get executionDelay(): BigInt {
    return this[0].toBigInt();
  }

  get scheduleDeposit(): GovernQueue__executeInput_containerConfigScheduleDepositStruct {
    return this[1].toTuple() as GovernQueue__executeInput_containerConfigScheduleDepositStruct;
  }

  get challengeDeposit(): GovernQueue__executeInput_containerConfigChallengeDepositStruct {
    return this[2].toTuple() as GovernQueue__executeInput_containerConfigChallengeDepositStruct;
  }

  get resolver(): Address {
    return this[3].toAddress();
  }

  get rules(): Bytes {
    return this[4].toBytes();
  }
}

export class GovernQueue__executeInput_containerConfigScheduleDepositStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}

export class GovernQueue__executeInput_containerConfigChallengeDepositStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}

export class GovernQueue__resolveResult {
  value0: Bytes;
  value1: Array<Bytes>;

  constructor(value0: Bytes, value1: Array<Bytes>) {
    this.value0 = value0;
    this.value1 = value1;
  }

  toMap(): TypedMap<string, ethereum.Value> {
    let map = new TypedMap<string, ethereum.Value>();
    map.set("value0", ethereum.Value.fromFixedBytes(this.value0));
    map.set("value1", ethereum.Value.fromBytesArray(this.value1));
    return map;
  }
}

export class GovernQueue__resolveInput_containerStruct extends ethereum.Tuple {
  get payload(): GovernQueue__resolveInput_containerPayloadStruct {
    return this[0].toTuple() as GovernQueue__resolveInput_containerPayloadStruct;
  }

  get config(): GovernQueue__resolveInput_containerConfigStruct {
    return this[1].toTuple() as GovernQueue__resolveInput_containerConfigStruct;
  }
}

export class GovernQueue__resolveInput_containerPayloadStruct extends ethereum.Tuple {
  get nonce(): BigInt {
    return this[0].toBigInt();
  }

  get executionTime(): BigInt {
    return this[1].toBigInt();
  }

  get submitter(): Address {
    return this[2].toAddress();
  }

  get executor(): Address {
    return this[3].toAddress();
  }

  get actions(): Array<
    GovernQueue__resolveInput_containerPayloadActionsStruct
  > {
    return this[4].toTupleArray<
      GovernQueue__resolveInput_containerPayloadActionsStruct
    >();
  }

  get allowFailuresMap(): Bytes {
    return this[5].toBytes();
  }

  get proof(): Bytes {
    return this[6].toBytes();
  }
}

export class GovernQueue__resolveInput_containerPayloadActionsStruct extends ethereum.Tuple {
  get to(): Address {
    return this[0].toAddress();
  }

  get value(): BigInt {
    return this[1].toBigInt();
  }

  get data(): Bytes {
    return this[2].toBytes();
  }
}

export class GovernQueue__resolveInput_containerConfigStruct extends ethereum.Tuple {
  get executionDelay(): BigInt {
    return this[0].toBigInt();
  }

  get scheduleDeposit(): GovernQueue__resolveInput_containerConfigScheduleDepositStruct {
    return this[1].toTuple() as GovernQueue__resolveInput_containerConfigScheduleDepositStruct;
  }

  get challengeDeposit(): GovernQueue__resolveInput_containerConfigChallengeDepositStruct {
    return this[2].toTuple() as GovernQueue__resolveInput_containerConfigChallengeDepositStruct;
  }

  get resolver(): Address {
    return this[3].toAddress();
  }

  get rules(): Bytes {
    return this[4].toBytes();
  }
}

export class GovernQueue__resolveInput_containerConfigScheduleDepositStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}

export class GovernQueue__resolveInput_containerConfigChallengeDepositStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}

export class GovernQueue__scheduleInput_containerStruct extends ethereum.Tuple {
  get payload(): GovernQueue__scheduleInput_containerPayloadStruct {
    return this[0].toTuple() as GovernQueue__scheduleInput_containerPayloadStruct;
  }

  get config(): GovernQueue__scheduleInput_containerConfigStruct {
    return this[1].toTuple() as GovernQueue__scheduleInput_containerConfigStruct;
  }
}

export class GovernQueue__scheduleInput_containerPayloadStruct extends ethereum.Tuple {
  get nonce(): BigInt {
    return this[0].toBigInt();
  }

  get executionTime(): BigInt {
    return this[1].toBigInt();
  }

  get submitter(): Address {
    return this[2].toAddress();
  }

  get executor(): Address {
    return this[3].toAddress();
  }

  get actions(): Array<
    GovernQueue__scheduleInput_containerPayloadActionsStruct
  > {
    return this[4].toTupleArray<
      GovernQueue__scheduleInput_containerPayloadActionsStruct
    >();
  }

  get allowFailuresMap(): Bytes {
    return this[5].toBytes();
  }

  get proof(): Bytes {
    return this[6].toBytes();
  }
}

export class GovernQueue__scheduleInput_containerPayloadActionsStruct extends ethereum.Tuple {
  get to(): Address {
    return this[0].toAddress();
  }

  get value(): BigInt {
    return this[1].toBigInt();
  }

  get data(): Bytes {
    return this[2].toBytes();
  }
}

export class GovernQueue__scheduleInput_containerConfigStruct extends ethereum.Tuple {
  get executionDelay(): BigInt {
    return this[0].toBigInt();
  }

  get scheduleDeposit(): GovernQueue__scheduleInput_containerConfigScheduleDepositStruct {
    return this[1].toTuple() as GovernQueue__scheduleInput_containerConfigScheduleDepositStruct;
  }

  get challengeDeposit(): GovernQueue__scheduleInput_containerConfigChallengeDepositStruct {
    return this[2].toTuple() as GovernQueue__scheduleInput_containerConfigChallengeDepositStruct;
  }

  get resolver(): Address {
    return this[3].toAddress();
  }

  get rules(): Bytes {
    return this[4].toBytes();
  }
}

export class GovernQueue__scheduleInput_containerConfigScheduleDepositStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}

export class GovernQueue__scheduleInput_containerConfigChallengeDepositStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}

export class GovernQueue extends ethereum.SmartContract {
  static bind(address: Address): GovernQueue {
    return new GovernQueue("GovernQueue", address);
  }

  ROOT_ROLE(): Bytes {
    let result = super.call("ROOT_ROLE", "ROOT_ROLE():(bytes4)", []);

    return result[0].toBytes();
  }

  try_ROOT_ROLE(): ethereum.CallResult<Bytes> {
    let result = super.tryCall("ROOT_ROLE", "ROOT_ROLE():(bytes4)", []);
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBytes());
  }

  challenge(
    _container: GovernQueue__challengeInput_containerStruct,
    _reason: Bytes
  ): BigInt {
    let result = super.call(
      "challenge",
      "challenge(((uint256,uint256,address,address,(address,uint256,bytes)[],bytes32,bytes),(uint256,(address,uint256),(address,uint256),address,bytes)),bytes):(uint256)",
      [ethereum.Value.fromTuple(_container), ethereum.Value.fromBytes(_reason)]
    );

    return result[0].toBigInt();
  }

  try_challenge(
    _container: GovernQueue__challengeInput_containerStruct,
    _reason: Bytes
  ): ethereum.CallResult<BigInt> {
    let result = super.tryCall(
      "challenge",
      "challenge(((uint256,uint256,address,address,(address,uint256,bytes)[],bytes32,bytes),(uint256,(address,uint256),(address,uint256),address,bytes)),bytes):(uint256)",
      [ethereum.Value.fromTuple(_container), ethereum.Value.fromBytes(_reason)]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBigInt());
  }

  challengerCache(param0: Bytes): Address {
    let result = super.call(
      "challengerCache",
      "challengerCache(bytes32):(address)",
      [ethereum.Value.fromFixedBytes(param0)]
    );

    return result[0].toAddress();
  }

  try_challengerCache(param0: Bytes): ethereum.CallResult<Address> {
    let result = super.tryCall(
      "challengerCache",
      "challengerCache(bytes32):(address)",
      [ethereum.Value.fromFixedBytes(param0)]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toAddress());
  }

  configHash(): Bytes {
    let result = super.call("configHash", "configHash():(bytes32)", []);

    return result[0].toBytes();
  }

  try_configHash(): ethereum.CallResult<Bytes> {
    let result = super.tryCall("configHash", "configHash():(bytes32)", []);
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBytes());
  }

  configure(_config: GovernQueue__configureInput_configStruct): Bytes {
    let result = super.call(
      "configure",
      "configure((uint256,(address,uint256),(address,uint256),address,bytes)):(bytes32)",
      [ethereum.Value.fromTuple(_config)]
    );

    return result[0].toBytes();
  }

  try_configure(
    _config: GovernQueue__configureInput_configStruct
  ): ethereum.CallResult<Bytes> {
    let result = super.tryCall(
      "configure",
      "configure((uint256,(address,uint256),(address,uint256),address,bytes)):(bytes32)",
      [ethereum.Value.fromTuple(_config)]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBytes());
  }

  disputeItemCache(param0: Bytes, param1: Address): BigInt {
    let result = super.call(
      "disputeItemCache",
      "disputeItemCache(bytes32,address):(uint256)",
      [
        ethereum.Value.fromFixedBytes(param0),
        ethereum.Value.fromAddress(param1)
      ]
    );

    return result[0].toBigInt();
  }

  try_disputeItemCache(
    param0: Bytes,
    param1: Address
  ): ethereum.CallResult<BigInt> {
    let result = super.tryCall(
      "disputeItemCache",
      "disputeItemCache(bytes32,address):(uint256)",
      [
        ethereum.Value.fromFixedBytes(param0),
        ethereum.Value.fromAddress(param1)
      ]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBigInt());
  }

  execute(
    _container: GovernQueue__executeInput_containerStruct
  ): GovernQueue__executeResult {
    let result = super.call(
      "execute",
      "execute(((uint256,uint256,address,address,(address,uint256,bytes)[],bytes32,bytes),(uint256,(address,uint256),(address,uint256),address,bytes))):(bytes32,bytes[])",
      [ethereum.Value.fromTuple(_container)]
    );

    return new GovernQueue__executeResult(
      result[0].toBytes(),
      result[1].toBytesArray()
    );
  }

  try_execute(
    _container: GovernQueue__executeInput_containerStruct
  ): ethereum.CallResult<GovernQueue__executeResult> {
    let result = super.tryCall(
      "execute",
      "execute(((uint256,uint256,address,address,(address,uint256,bytes)[],bytes32,bytes),(uint256,(address,uint256),(address,uint256),address,bytes))):(bytes32,bytes[])",
      [ethereum.Value.fromTuple(_container)]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(
      new GovernQueue__executeResult(
        value[0].toBytes(),
        value[1].toBytesArray()
      )
    );
  }

  initBlocks(param0: string): BigInt {
    let result = super.call("initBlocks", "initBlocks(string):(uint256)", [
      ethereum.Value.fromString(param0)
    ]);

    return result[0].toBigInt();
  }

  try_initBlocks(param0: string): ethereum.CallResult<BigInt> {
    let result = super.tryCall("initBlocks", "initBlocks(string):(uint256)", [
      ethereum.Value.fromString(param0)
    ]);
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBigInt());
  }

  isFrozen(_role: Bytes): boolean {
    let result = super.call("isFrozen", "isFrozen(bytes4):(bool)", [
      ethereum.Value.fromFixedBytes(_role)
    ]);

    return result[0].toBoolean();
  }

  try_isFrozen(_role: Bytes): ethereum.CallResult<boolean> {
    let result = super.tryCall("isFrozen", "isFrozen(bytes4):(bool)", [
      ethereum.Value.fromFixedBytes(_role)
    ]);
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBoolean());
  }

  nonce(): BigInt {
    let result = super.call("nonce", "nonce():(uint256)", []);

    return result[0].toBigInt();
  }

  try_nonce(): ethereum.CallResult<BigInt> {
    let result = super.tryCall("nonce", "nonce():(uint256)", []);
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBigInt());
  }

  queue(param0: Bytes): i32 {
    let result = super.call("queue", "queue(bytes32):(uint8)", [
      ethereum.Value.fromFixedBytes(param0)
    ]);

    return result[0].toI32();
  }

  try_queue(param0: Bytes): ethereum.CallResult<i32> {
    let result = super.tryCall("queue", "queue(bytes32):(uint8)", [
      ethereum.Value.fromFixedBytes(param0)
    ]);
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toI32());
  }

  resolve(
    _container: GovernQueue__resolveInput_containerStruct,
    _disputeId: BigInt
  ): GovernQueue__resolveResult {
    let result = super.call(
      "resolve",
      "resolve(((uint256,uint256,address,address,(address,uint256,bytes)[],bytes32,bytes),(uint256,(address,uint256),(address,uint256),address,bytes)),uint256):(bytes32,bytes[])",
      [
        ethereum.Value.fromTuple(_container),
        ethereum.Value.fromUnsignedBigInt(_disputeId)
      ]
    );

    return new GovernQueue__resolveResult(
      result[0].toBytes(),
      result[1].toBytesArray()
    );
  }

  try_resolve(
    _container: GovernQueue__resolveInput_containerStruct,
    _disputeId: BigInt
  ): ethereum.CallResult<GovernQueue__resolveResult> {
    let result = super.tryCall(
      "resolve",
      "resolve(((uint256,uint256,address,address,(address,uint256,bytes)[],bytes32,bytes),(uint256,(address,uint256),(address,uint256),address,bytes)),uint256):(bytes32,bytes[])",
      [
        ethereum.Value.fromTuple(_container),
        ethereum.Value.fromUnsignedBigInt(_disputeId)
      ]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(
      new GovernQueue__resolveResult(
        value[0].toBytes(),
        value[1].toBytesArray()
      )
    );
  }

  roles(param0: Bytes, param1: Address): Address {
    let result = super.call("roles", "roles(bytes4,address):(address)", [
      ethereum.Value.fromFixedBytes(param0),
      ethereum.Value.fromAddress(param1)
    ]);

    return result[0].toAddress();
  }

  try_roles(param0: Bytes, param1: Address): ethereum.CallResult<Address> {
    let result = super.tryCall("roles", "roles(bytes4,address):(address)", [
      ethereum.Value.fromFixedBytes(param0),
      ethereum.Value.fromAddress(param1)
    ]);
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toAddress());
  }

  schedule(_container: GovernQueue__scheduleInput_containerStruct): Bytes {
    let result = super.call(
      "schedule",
      "schedule(((uint256,uint256,address,address,(address,uint256,bytes)[],bytes32,bytes),(uint256,(address,uint256),(address,uint256),address,bytes))):(bytes32)",
      [ethereum.Value.fromTuple(_container)]
    );

    return result[0].toBytes();
  }

  try_schedule(
    _container: GovernQueue__scheduleInput_containerStruct
  ): ethereum.CallResult<Bytes> {
    let result = super.tryCall(
      "schedule",
      "schedule(((uint256,uint256,address,address,(address,uint256,bytes)[],bytes32,bytes),(uint256,(address,uint256),(address,uint256),address,bytes))):(bytes32)",
      [ethereum.Value.fromTuple(_container)]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBytes());
  }

  supportsInterface(_interfaceId: Bytes): boolean {
    let result = super.call(
      "supportsInterface",
      "supportsInterface(bytes4):(bool)",
      [ethereum.Value.fromFixedBytes(_interfaceId)]
    );

    return result[0].toBoolean();
  }

  try_supportsInterface(_interfaceId: Bytes): ethereum.CallResult<boolean> {
    let result = super.tryCall(
      "supportsInterface",
      "supportsInterface(bytes4):(bool)",
      [ethereum.Value.fromFixedBytes(_interfaceId)]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBoolean());
  }
}

export class ConstructorCall extends ethereum.Call {
  get inputs(): ConstructorCall__Inputs {
    return new ConstructorCall__Inputs(this);
  }

  get outputs(): ConstructorCall__Outputs {
    return new ConstructorCall__Outputs(this);
  }
}

export class ConstructorCall__Inputs {
  _call: ConstructorCall;

  constructor(call: ConstructorCall) {
    this._call = call;
  }

  get _aclRoot(): Address {
    return this._call.inputValues[0].value.toAddress();
  }

  get _initialConfig(): ConstructorCall_initialConfigStruct {
    return this._call.inputValues[1].value.toTuple() as ConstructorCall_initialConfigStruct;
  }
}

export class ConstructorCall__Outputs {
  _call: ConstructorCall;

  constructor(call: ConstructorCall) {
    this._call = call;
  }
}

export class ConstructorCall_initialConfigStruct extends ethereum.Tuple {
  get executionDelay(): BigInt {
    return this[0].toBigInt();
  }

  get scheduleDeposit(): ConstructorCall_initialConfigScheduleDepositStruct {
    return this[1].toTuple() as ConstructorCall_initialConfigScheduleDepositStruct;
  }

  get challengeDeposit(): ConstructorCall_initialConfigChallengeDepositStruct {
    return this[2].toTuple() as ConstructorCall_initialConfigChallengeDepositStruct;
  }

  get resolver(): Address {
    return this[3].toAddress();
  }

  get rules(): Bytes {
    return this[4].toBytes();
  }
}

export class ConstructorCall_initialConfigScheduleDepositStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}

export class ConstructorCall_initialConfigChallengeDepositStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}

export class BulkCall extends ethereum.Call {
  get inputs(): BulkCall__Inputs {
    return new BulkCall__Inputs(this);
  }

  get outputs(): BulkCall__Outputs {
    return new BulkCall__Outputs(this);
  }
}

export class BulkCall__Inputs {
  _call: BulkCall;

  constructor(call: BulkCall) {
    this._call = call;
  }

  get items(): Array<BulkCallItemsStruct> {
    return this._call.inputValues[0].value.toTupleArray<BulkCallItemsStruct>();
  }
}

export class BulkCall__Outputs {
  _call: BulkCall;

  constructor(call: BulkCall) {
    this._call = call;
  }
}

export class BulkCallItemsStruct extends ethereum.Tuple {
  get op(): i32 {
    return this[0].toI32();
  }

  get role(): Bytes {
    return this[1].toBytes();
  }

  get who(): Address {
    return this[2].toAddress();
  }
}

export class ChallengeCall extends ethereum.Call {
  get inputs(): ChallengeCall__Inputs {
    return new ChallengeCall__Inputs(this);
  }

  get outputs(): ChallengeCall__Outputs {
    return new ChallengeCall__Outputs(this);
  }
}

export class ChallengeCall__Inputs {
  _call: ChallengeCall;

  constructor(call: ChallengeCall) {
    this._call = call;
  }

  get _container(): ChallengeCall_containerStruct {
    return this._call.inputValues[0].value.toTuple() as ChallengeCall_containerStruct;
  }

  get _reason(): Bytes {
    return this._call.inputValues[1].value.toBytes();
  }
}

export class ChallengeCall__Outputs {
  _call: ChallengeCall;

  constructor(call: ChallengeCall) {
    this._call = call;
  }

  get disputeId(): BigInt {
    return this._call.outputValues[0].value.toBigInt();
  }
}

export class ChallengeCall_containerStruct extends ethereum.Tuple {
  get payload(): ChallengeCall_containerPayloadStruct {
    return this[0].toTuple() as ChallengeCall_containerPayloadStruct;
  }

  get config(): ChallengeCall_containerConfigStruct {
    return this[1].toTuple() as ChallengeCall_containerConfigStruct;
  }
}

export class ChallengeCall_containerPayloadStruct extends ethereum.Tuple {
  get nonce(): BigInt {
    return this[0].toBigInt();
  }

  get executionTime(): BigInt {
    return this[1].toBigInt();
  }

  get submitter(): Address {
    return this[2].toAddress();
  }

  get executor(): Address {
    return this[3].toAddress();
  }

  get actions(): Array<ChallengeCall_containerPayloadActionsStruct> {
    return this[4].toTupleArray<ChallengeCall_containerPayloadActionsStruct>();
  }

  get allowFailuresMap(): Bytes {
    return this[5].toBytes();
  }

  get proof(): Bytes {
    return this[6].toBytes();
  }
}

export class ChallengeCall_containerPayloadActionsStruct extends ethereum.Tuple {
  get to(): Address {
    return this[0].toAddress();
  }

  get value(): BigInt {
    return this[1].toBigInt();
  }

  get data(): Bytes {
    return this[2].toBytes();
  }
}

export class ChallengeCall_containerConfigStruct extends ethereum.Tuple {
  get executionDelay(): BigInt {
    return this[0].toBigInt();
  }

  get scheduleDeposit(): ChallengeCall_containerConfigScheduleDepositStruct {
    return this[1].toTuple() as ChallengeCall_containerConfigScheduleDepositStruct;
  }

  get challengeDeposit(): ChallengeCall_containerConfigChallengeDepositStruct {
    return this[2].toTuple() as ChallengeCall_containerConfigChallengeDepositStruct;
  }

  get resolver(): Address {
    return this[3].toAddress();
  }

  get rules(): Bytes {
    return this[4].toBytes();
  }
}

export class ChallengeCall_containerConfigScheduleDepositStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}

export class ChallengeCall_containerConfigChallengeDepositStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}

export class ConfigureCall extends ethereum.Call {
  get inputs(): ConfigureCall__Inputs {
    return new ConfigureCall__Inputs(this);
  }

  get outputs(): ConfigureCall__Outputs {
    return new ConfigureCall__Outputs(this);
  }
}

export class ConfigureCall__Inputs {
  _call: ConfigureCall;

  constructor(call: ConfigureCall) {
    this._call = call;
  }

  get _config(): ConfigureCall_configStruct {
    return this._call.inputValues[0].value.toTuple() as ConfigureCall_configStruct;
  }
}

export class ConfigureCall__Outputs {
  _call: ConfigureCall;

  constructor(call: ConfigureCall) {
    this._call = call;
  }

  get value0(): Bytes {
    return this._call.outputValues[0].value.toBytes();
  }
}

export class ConfigureCall_configStruct extends ethereum.Tuple {
  get executionDelay(): BigInt {
    return this[0].toBigInt();
  }

  get scheduleDeposit(): ConfigureCall_configScheduleDepositStruct {
    return this[1].toTuple() as ConfigureCall_configScheduleDepositStruct;
  }

  get challengeDeposit(): ConfigureCall_configChallengeDepositStruct {
    return this[2].toTuple() as ConfigureCall_configChallengeDepositStruct;
  }

  get resolver(): Address {
    return this[3].toAddress();
  }

  get rules(): Bytes {
    return this[4].toBytes();
  }
}

export class ConfigureCall_configScheduleDepositStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}

export class ConfigureCall_configChallengeDepositStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}

export class ExecuteCall extends ethereum.Call {
  get inputs(): ExecuteCall__Inputs {
    return new ExecuteCall__Inputs(this);
  }

  get outputs(): ExecuteCall__Outputs {
    return new ExecuteCall__Outputs(this);
  }
}

export class ExecuteCall__Inputs {
  _call: ExecuteCall;

  constructor(call: ExecuteCall) {
    this._call = call;
  }

  get _container(): ExecuteCall_containerStruct {
    return this._call.inputValues[0].value.toTuple() as ExecuteCall_containerStruct;
  }
}

export class ExecuteCall__Outputs {
  _call: ExecuteCall;

  constructor(call: ExecuteCall) {
    this._call = call;
  }

  get failureMap(): Bytes {
    return this._call.outputValues[0].value.toBytes();
  }

  get value1(): Array<Bytes> {
    return this._call.outputValues[1].value.toBytesArray();
  }
}

export class ExecuteCall_containerStruct extends ethereum.Tuple {
  get payload(): ExecuteCall_containerPayloadStruct {
    return this[0].toTuple() as ExecuteCall_containerPayloadStruct;
  }

  get config(): ExecuteCall_containerConfigStruct {
    return this[1].toTuple() as ExecuteCall_containerConfigStruct;
  }
}

export class ExecuteCall_containerPayloadStruct extends ethereum.Tuple {
  get nonce(): BigInt {
    return this[0].toBigInt();
  }

  get executionTime(): BigInt {
    return this[1].toBigInt();
  }

  get submitter(): Address {
    return this[2].toAddress();
  }

  get executor(): Address {
    return this[3].toAddress();
  }

  get actions(): Array<ExecuteCall_containerPayloadActionsStruct> {
    return this[4].toTupleArray<ExecuteCall_containerPayloadActionsStruct>();
  }

  get allowFailuresMap(): Bytes {
    return this[5].toBytes();
  }

  get proof(): Bytes {
    return this[6].toBytes();
  }
}

export class ExecuteCall_containerPayloadActionsStruct extends ethereum.Tuple {
  get to(): Address {
    return this[0].toAddress();
  }

  get value(): BigInt {
    return this[1].toBigInt();
  }

  get data(): Bytes {
    return this[2].toBytes();
  }
}

export class ExecuteCall_containerConfigStruct extends ethereum.Tuple {
  get executionDelay(): BigInt {
    return this[0].toBigInt();
  }

  get scheduleDeposit(): ExecuteCall_containerConfigScheduleDepositStruct {
    return this[1].toTuple() as ExecuteCall_containerConfigScheduleDepositStruct;
  }

  get challengeDeposit(): ExecuteCall_containerConfigChallengeDepositStruct {
    return this[2].toTuple() as ExecuteCall_containerConfigChallengeDepositStruct;
  }

  get resolver(): Address {
    return this[3].toAddress();
  }

  get rules(): Bytes {
    return this[4].toBytes();
  }
}

export class ExecuteCall_containerConfigScheduleDepositStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}

export class ExecuteCall_containerConfigChallengeDepositStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}

export class FreezeCall extends ethereum.Call {
  get inputs(): FreezeCall__Inputs {
    return new FreezeCall__Inputs(this);
  }

  get outputs(): FreezeCall__Outputs {
    return new FreezeCall__Outputs(this);
  }
}

export class FreezeCall__Inputs {
  _call: FreezeCall;

  constructor(call: FreezeCall) {
    this._call = call;
  }

  get _role(): Bytes {
    return this._call.inputValues[0].value.toBytes();
  }
}

export class FreezeCall__Outputs {
  _call: FreezeCall;

  constructor(call: FreezeCall) {
    this._call = call;
  }
}

export class GrantCall extends ethereum.Call {
  get inputs(): GrantCall__Inputs {
    return new GrantCall__Inputs(this);
  }

  get outputs(): GrantCall__Outputs {
    return new GrantCall__Outputs(this);
  }
}

export class GrantCall__Inputs {
  _call: GrantCall;

  constructor(call: GrantCall) {
    this._call = call;
  }

  get _role(): Bytes {
    return this._call.inputValues[0].value.toBytes();
  }

  get _who(): Address {
    return this._call.inputValues[1].value.toAddress();
  }
}

export class GrantCall__Outputs {
  _call: GrantCall;

  constructor(call: GrantCall) {
    this._call = call;
  }
}

export class GrantWithOracleCall extends ethereum.Call {
  get inputs(): GrantWithOracleCall__Inputs {
    return new GrantWithOracleCall__Inputs(this);
  }

  get outputs(): GrantWithOracleCall__Outputs {
    return new GrantWithOracleCall__Outputs(this);
  }
}

export class GrantWithOracleCall__Inputs {
  _call: GrantWithOracleCall;

  constructor(call: GrantWithOracleCall) {
    this._call = call;
  }

  get _role(): Bytes {
    return this._call.inputValues[0].value.toBytes();
  }

  get _who(): Address {
    return this._call.inputValues[1].value.toAddress();
  }

  get _oracle(): Address {
    return this._call.inputValues[2].value.toAddress();
  }
}

export class GrantWithOracleCall__Outputs {
  _call: GrantWithOracleCall;

  constructor(call: GrantWithOracleCall) {
    this._call = call;
  }
}

export class InitializeCall extends ethereum.Call {
  get inputs(): InitializeCall__Inputs {
    return new InitializeCall__Inputs(this);
  }

  get outputs(): InitializeCall__Outputs {
    return new InitializeCall__Outputs(this);
  }
}

export class InitializeCall__Inputs {
  _call: InitializeCall;

  constructor(call: InitializeCall) {
    this._call = call;
  }

  get _aclRoot(): Address {
    return this._call.inputValues[0].value.toAddress();
  }

  get _initialConfig(): InitializeCall_initialConfigStruct {
    return this._call.inputValues[1].value.toTuple() as InitializeCall_initialConfigStruct;
  }
}

export class InitializeCall__Outputs {
  _call: InitializeCall;

  constructor(call: InitializeCall) {
    this._call = call;
  }
}

export class InitializeCall_initialConfigStruct extends ethereum.Tuple {
  get executionDelay(): BigInt {
    return this[0].toBigInt();
  }

  get scheduleDeposit(): InitializeCall_initialConfigScheduleDepositStruct {
    return this[1].toTuple() as InitializeCall_initialConfigScheduleDepositStruct;
  }

  get challengeDeposit(): InitializeCall_initialConfigChallengeDepositStruct {
    return this[2].toTuple() as InitializeCall_initialConfigChallengeDepositStruct;
  }

  get resolver(): Address {
    return this[3].toAddress();
  }

  get rules(): Bytes {
    return this[4].toBytes();
  }
}

export class InitializeCall_initialConfigScheduleDepositStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}

export class InitializeCall_initialConfigChallengeDepositStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}

export class ResolveCall extends ethereum.Call {
  get inputs(): ResolveCall__Inputs {
    return new ResolveCall__Inputs(this);
  }

  get outputs(): ResolveCall__Outputs {
    return new ResolveCall__Outputs(this);
  }
}

export class ResolveCall__Inputs {
  _call: ResolveCall;

  constructor(call: ResolveCall) {
    this._call = call;
  }

  get _container(): ResolveCall_containerStruct {
    return this._call.inputValues[0].value.toTuple() as ResolveCall_containerStruct;
  }

  get _disputeId(): BigInt {
    return this._call.inputValues[1].value.toBigInt();
  }
}

export class ResolveCall__Outputs {
  _call: ResolveCall;

  constructor(call: ResolveCall) {
    this._call = call;
  }

  get failureMap(): Bytes {
    return this._call.outputValues[0].value.toBytes();
  }

  get value1(): Array<Bytes> {
    return this._call.outputValues[1].value.toBytesArray();
  }
}

export class ResolveCall_containerStruct extends ethereum.Tuple {
  get payload(): ResolveCall_containerPayloadStruct {
    return this[0].toTuple() as ResolveCall_containerPayloadStruct;
  }

  get config(): ResolveCall_containerConfigStruct {
    return this[1].toTuple() as ResolveCall_containerConfigStruct;
  }
}

export class ResolveCall_containerPayloadStruct extends ethereum.Tuple {
  get nonce(): BigInt {
    return this[0].toBigInt();
  }

  get executionTime(): BigInt {
    return this[1].toBigInt();
  }

  get submitter(): Address {
    return this[2].toAddress();
  }

  get executor(): Address {
    return this[3].toAddress();
  }

  get actions(): Array<ResolveCall_containerPayloadActionsStruct> {
    return this[4].toTupleArray<ResolveCall_containerPayloadActionsStruct>();
  }

  get allowFailuresMap(): Bytes {
    return this[5].toBytes();
  }

  get proof(): Bytes {
    return this[6].toBytes();
  }
}

export class ResolveCall_containerPayloadActionsStruct extends ethereum.Tuple {
  get to(): Address {
    return this[0].toAddress();
  }

  get value(): BigInt {
    return this[1].toBigInt();
  }

  get data(): Bytes {
    return this[2].toBytes();
  }
}

export class ResolveCall_containerConfigStruct extends ethereum.Tuple {
  get executionDelay(): BigInt {
    return this[0].toBigInt();
  }

  get scheduleDeposit(): ResolveCall_containerConfigScheduleDepositStruct {
    return this[1].toTuple() as ResolveCall_containerConfigScheduleDepositStruct;
  }

  get challengeDeposit(): ResolveCall_containerConfigChallengeDepositStruct {
    return this[2].toTuple() as ResolveCall_containerConfigChallengeDepositStruct;
  }

  get resolver(): Address {
    return this[3].toAddress();
  }

  get rules(): Bytes {
    return this[4].toBytes();
  }
}

export class ResolveCall_containerConfigScheduleDepositStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}

export class ResolveCall_containerConfigChallengeDepositStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}

export class RevokeCall extends ethereum.Call {
  get inputs(): RevokeCall__Inputs {
    return new RevokeCall__Inputs(this);
  }

  get outputs(): RevokeCall__Outputs {
    return new RevokeCall__Outputs(this);
  }
}

export class RevokeCall__Inputs {
  _call: RevokeCall;

  constructor(call: RevokeCall) {
    this._call = call;
  }

  get _role(): Bytes {
    return this._call.inputValues[0].value.toBytes();
  }

  get _who(): Address {
    return this._call.inputValues[1].value.toAddress();
  }
}

export class RevokeCall__Outputs {
  _call: RevokeCall;

  constructor(call: RevokeCall) {
    this._call = call;
  }
}

export class ScheduleCall extends ethereum.Call {
  get inputs(): ScheduleCall__Inputs {
    return new ScheduleCall__Inputs(this);
  }

  get outputs(): ScheduleCall__Outputs {
    return new ScheduleCall__Outputs(this);
  }
}

export class ScheduleCall__Inputs {
  _call: ScheduleCall;

  constructor(call: ScheduleCall) {
    this._call = call;
  }

  get _container(): ScheduleCall_containerStruct {
    return this._call.inputValues[0].value.toTuple() as ScheduleCall_containerStruct;
  }
}

export class ScheduleCall__Outputs {
  _call: ScheduleCall;

  constructor(call: ScheduleCall) {
    this._call = call;
  }

  get containerHash(): Bytes {
    return this._call.outputValues[0].value.toBytes();
  }
}

export class ScheduleCall_containerStruct extends ethereum.Tuple {
  get payload(): ScheduleCall_containerPayloadStruct {
    return this[0].toTuple() as ScheduleCall_containerPayloadStruct;
  }

  get config(): ScheduleCall_containerConfigStruct {
    return this[1].toTuple() as ScheduleCall_containerConfigStruct;
  }
}

export class ScheduleCall_containerPayloadStruct extends ethereum.Tuple {
  get nonce(): BigInt {
    return this[0].toBigInt();
  }

  get executionTime(): BigInt {
    return this[1].toBigInt();
  }

  get submitter(): Address {
    return this[2].toAddress();
  }

  get executor(): Address {
    return this[3].toAddress();
  }

  get actions(): Array<ScheduleCall_containerPayloadActionsStruct> {
    return this[4].toTupleArray<ScheduleCall_containerPayloadActionsStruct>();
  }

  get allowFailuresMap(): Bytes {
    return this[5].toBytes();
  }

  get proof(): Bytes {
    return this[6].toBytes();
  }
}

export class ScheduleCall_containerPayloadActionsStruct extends ethereum.Tuple {
  get to(): Address {
    return this[0].toAddress();
  }

  get value(): BigInt {
    return this[1].toBigInt();
  }

  get data(): Bytes {
    return this[2].toBytes();
  }
}

export class ScheduleCall_containerConfigStruct extends ethereum.Tuple {
  get executionDelay(): BigInt {
    return this[0].toBigInt();
  }

  get scheduleDeposit(): ScheduleCall_containerConfigScheduleDepositStruct {
    return this[1].toTuple() as ScheduleCall_containerConfigScheduleDepositStruct;
  }

  get challengeDeposit(): ScheduleCall_containerConfigChallengeDepositStruct {
    return this[2].toTuple() as ScheduleCall_containerConfigChallengeDepositStruct;
  }

  get resolver(): Address {
    return this[3].toAddress();
  }

  get rules(): Bytes {
    return this[4].toBytes();
  }
}

export class ScheduleCall_containerConfigScheduleDepositStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}

export class ScheduleCall_containerConfigChallengeDepositStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}

export class VetoCall extends ethereum.Call {
  get inputs(): VetoCall__Inputs {
    return new VetoCall__Inputs(this);
  }

  get outputs(): VetoCall__Outputs {
    return new VetoCall__Outputs(this);
  }
}

export class VetoCall__Inputs {
  _call: VetoCall;

  constructor(call: VetoCall) {
    this._call = call;
  }

  get _container(): VetoCall_containerStruct {
    return this._call.inputValues[0].value.toTuple() as VetoCall_containerStruct;
  }

  get _reason(): Bytes {
    return this._call.inputValues[1].value.toBytes();
  }
}

export class VetoCall__Outputs {
  _call: VetoCall;

  constructor(call: VetoCall) {
    this._call = call;
  }
}

export class VetoCall_containerStruct extends ethereum.Tuple {
  get payload(): VetoCall_containerPayloadStruct {
    return this[0].toTuple() as VetoCall_containerPayloadStruct;
  }

  get config(): VetoCall_containerConfigStruct {
    return this[1].toTuple() as VetoCall_containerConfigStruct;
  }
}

export class VetoCall_containerPayloadStruct extends ethereum.Tuple {
  get nonce(): BigInt {
    return this[0].toBigInt();
  }

  get executionTime(): BigInt {
    return this[1].toBigInt();
  }

  get submitter(): Address {
    return this[2].toAddress();
  }

  get executor(): Address {
    return this[3].toAddress();
  }

  get actions(): Array<VetoCall_containerPayloadActionsStruct> {
    return this[4].toTupleArray<VetoCall_containerPayloadActionsStruct>();
  }

  get allowFailuresMap(): Bytes {
    return this[5].toBytes();
  }

  get proof(): Bytes {
    return this[6].toBytes();
  }
}

export class VetoCall_containerPayloadActionsStruct extends ethereum.Tuple {
  get to(): Address {
    return this[0].toAddress();
  }

  get value(): BigInt {
    return this[1].toBigInt();
  }

  get data(): Bytes {
    return this[2].toBytes();
  }
}

export class VetoCall_containerConfigStruct extends ethereum.Tuple {
  get executionDelay(): BigInt {
    return this[0].toBigInt();
  }

  get scheduleDeposit(): VetoCall_containerConfigScheduleDepositStruct {
    return this[1].toTuple() as VetoCall_containerConfigScheduleDepositStruct;
  }

  get challengeDeposit(): VetoCall_containerConfigChallengeDepositStruct {
    return this[2].toTuple() as VetoCall_containerConfigChallengeDepositStruct;
  }

  get resolver(): Address {
    return this[3].toAddress();
  }

  get rules(): Bytes {
    return this[4].toBytes();
  }
}

export class VetoCall_containerConfigScheduleDepositStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}

export class VetoCall_containerConfigChallengeDepositStruct extends ethereum.Tuple {
  get token(): Address {
    return this[0].toAddress();
  }

  get amount(): BigInt {
    return this[1].toBigInt();
  }
}