amgi-ts/dist/index.d.ts

Typescript SDK for interacting with various AMGI Studios Eth Contracts.

import { Contract, ContractRunner, BlockTag, EventLog, Log, BytesLike, AddressLike, Interface } from 'ethers';

interface ProposalCreatedEvent {
    proposalId: bigint;
    proposer: string;
    targets: string[];
    values: bigint[];
    signatures: string[];
    calldatas: string[];
    voteStart: bigint;
    voteEnd: bigint;
    description: string;
}
interface ProposalCanceledEvent {
    proposalId: bigint;
}
interface ProposalCanceledByCancellerEvent {
    canceller: string;
    proposalId: bigint;
    reason: string;
}
interface ProposalExecutedEvent {
    proposalId: bigint;
}
interface ProposalQueuedEvent {
    proposalId: bigint;
    etaSeconds: bigint;
}
interface ProposalThresholdSetEvent {
    oldProposalThreshold: bigint;
    newProposalThreshold: bigint;
}
interface QuorumNumeratorUpdatedEvent {
    oldQuorumNumerator: bigint;
    newQuorumNumerator: bigint;
}
interface RoleAdminChangedEvent$2 {
    role: string;
    previousAdminRole: string;
    newAdminRole: string;
}
interface RoleGrantedEvent$2 {
    role: string;
    account: string;
    sender: string;
}
interface RoleRevokedEvent$1 {
    role: string;
    account: string;
    sender: string;
}
interface TimelockChangeEvent {
    oldTimelock: string;
    newTimelock: string;
}
interface VoteCastEvent {
    voter: string;
    proposalId: bigint;
    support: number;
    weight: bigint;
    reason: string;
}
interface VoteCastWithParamsEvent {
    voter: string;
    proposalId: bigint;
    support: number;
    weight: bigint;
    reason: string;
    params: string;
}
interface VotingDelaySetEvent {
    oldVotingDelay: bigint;
    newVotingDelay: bigint;
}
interface VotingPeriodSetEvent {
    oldVotingPeriod: bigint;
    newVotingPeriod: bigint;
}
interface EIP712DomainChangedEvent$2 {
}
interface GovernorEvents {
    ProposalCreated: ProposalCreatedEvent;
    ProposalCanceled: ProposalCanceledEvent;
    ProposalCanceledByCanceller: ProposalCanceledByCancellerEvent;
    ProposalExecuted: ProposalExecutedEvent;
    ProposalQueued: ProposalQueuedEvent;
    ProposalThresholdSet: ProposalThresholdSetEvent;
    QuorumNumeratorUpdated: QuorumNumeratorUpdatedEvent;
    RoleAdminChanged: RoleAdminChangedEvent$2;
    RoleGranted: RoleGrantedEvent$2;
    RoleRevoked: RoleRevokedEvent$1;
    TimelockChange: TimelockChangeEvent;
    VoteCast: VoteCastEvent;
    VoteCastWithParams: VoteCastWithParamsEvent;
    VotingDelaySet: VotingDelaySetEvent;
    VotingPeriodSet: VotingPeriodSetEvent;
    EIP712DomainChanged: EIP712DomainChangedEvent$2;
}

type EventCallback<T> = (args: T) => void;
declare class BaseEvents<EventTypes> {
    protected contract: Contract;
    constructor(contract: Contract);
    protected on<K extends keyof EventTypes>(eventName: K, callback: EventCallback<EventTypes[K]>): Promise<void>;
    protected parseEventArgs<K extends keyof EventTypes>(eventName: K, args: any[]): EventTypes[K];
    changeRunner(runner: ContractRunner): void;
}

declare class Events$4 extends BaseEvents<GovernorEvents> {
    constructor(contract: Contract);
    proposalCreated(callback: EventCallback<GovernorEvents["ProposalCreated"]>): Promise<void>;
    proposalCanceled(callback: EventCallback<GovernorEvents["ProposalCanceled"]>): Promise<void>;
    proposalCanceledByCanceller(callback: EventCallback<GovernorEvents["ProposalCanceledByCanceller"]>): Promise<void>;
    proposalExecuted(callback: EventCallback<GovernorEvents["ProposalExecuted"]>): Promise<void>;
    proposalQueued(callback: EventCallback<GovernorEvents["ProposalQueued"]>): Promise<void>;
    proposalThresholdSet(callback: EventCallback<GovernorEvents["ProposalThresholdSet"]>): Promise<void>;
    quorumNumeratorUpdated(callback: EventCallback<GovernorEvents["QuorumNumeratorUpdated"]>): Promise<void>;
    roleAdminChanged(callback: EventCallback<GovernorEvents["RoleAdminChanged"]>): Promise<void>;
    roleGranted(callback: EventCallback<GovernorEvents["RoleGranted"]>): Promise<void>;
    roleRevoked(callback: EventCallback<GovernorEvents["RoleRevoked"]>): Promise<void>;
    timelockChange(callback: EventCallback<GovernorEvents["TimelockChange"]>): Promise<void>;
    voteCast(callback: EventCallback<GovernorEvents["VoteCast"]>): Promise<void>;
    voteCastWithParams(callback: EventCallback<GovernorEvents["VoteCastWithParams"]>): Promise<void>;
    votingDelaySet(callback: EventCallback<GovernorEvents["VotingDelaySet"]>): Promise<void>;
    votingPeriodSet(callback: EventCallback<GovernorEvents["VotingPeriodSet"]>): Promise<void>;
    eip712DomainChanged(callback: EventCallback<GovernorEvents["EIP712DomainChanged"]>): Promise<void>;
}

interface ProposalVotes {
    against: bigint;
    for: bigint;
    abstain: bigint;
    total: bigint;
}
declare class Fetch$4 {
    private contract;
    constructor(contract: Contract);
    proposalCreated(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    proposalCanceled(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    proposalCanceledByCanceller(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    proposalExecuted(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    proposalQueued(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    proposalThresholdSet(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    quorumNumeratorUpdated(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    roleAdminChanged(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    roleGranted(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    roleRevoked(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    timelockChange(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    voteCast(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    voteCastWithParams(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    votingDelaySet(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    votingPeriodSet(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    domainChanged(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    ballotTypehash(): Promise<BytesLike>;
    cancellerRole(): Promise<BytesLike>;
    clockMode(): Promise<string>;
    clock(): Promise<number>;
    countingMode(): Promise<string>;
    defaultAdminRole(): Promise<BytesLike>;
    domain(): Promise<any>;
    extendedBallotTypehash(): Promise<string>;
    circulatingSupply(): Promise<bigint>;
    getIncreaseNumerator(): Promise<bigint>;
    getRoleAdmin(role: BytesLike): Promise<BytesLike>;
    getVotes(account: AddressLike, timepoint: bigint): Promise<bigint>;
    getVotesWithParams(account: AddressLike, timepoint: bigint, params: BytesLike): Promise<bigint>;
    hasRole(role: BytesLike, account: AddressLike): Promise<boolean>;
    hasVoted(proposalId: bigint, account: AddressLike): Promise<boolean>;
    isATarget(targets: AddressLike[]): Promise<boolean>;
    karrat(): Promise<AddressLike>;
    lastAdjustedCancelerRole(): Promise<bigint>;
    name(): Promise<string>;
    nonces(owner: AddressLike): Promise<bigint>;
    notCirculatingWalletOne(): Promise<AddressLike>;
    notCirculatingWalletTwo(): Promise<AddressLike>;
    proposalDeadline(proposalId: bigint): Promise<bigint>;
    proposalEta(proposalId: bigint): Promise<bigint>;
    proposalNeedsQueuing(proposalId: bigint): Promise<boolean>;
    proposalProposer(proposalId: bigint): Promise<AddressLike>;
    proposalSnapshot(proposalId: bigint): Promise<BlockTag>;
    proposalThreshold(proposalId: bigint): Promise<BlockTag>;
    proposalVotes(proposalId: bigint): Promise<ProposalVotes>;
    quorum(timepoint: BlockTag): Promise<bigint>;
    quorumDenominator(): Promise<bigint>;
    quorumNumerator(timepoint?: bigint): Promise<bigint>;
    state(proposalId: bigint): Promise<number>;
    supportsInterface(interfaceId: BytesLike): Promise<boolean>;
    timelock(): Promise<AddressLike>;
    timelockControllerAddress(): Promise<AddressLike>;
    token(): Promise<AddressLike>;
    version(): Promise<string>;
    votingDelay(): Promise<bigint>;
    votingPeriod(): Promise<bigint>;
    changeRunner(runner: ContractRunner): void;
}

declare class Execute$2 {
    private contract;
    constructor(contract: Contract);
    cancel(targets: AddressLike[], values: bigint[], calldatas: BytesLike[], proposalDescription: BytesLike): Promise<any>;
    cancelProposal(targets: AddressLike[], values: bigint[], calldatas: BytesLike[], proposalDescription: BytesLike, proposalId: bigint, reason: string): Promise<any>;
    cancelProposalInTimelock(proposalId: bigint, id: BytesLike, reason: string): Promise<any>;
    cancellerRemoval(remove: AddressLike): Promise<any>;
    castVote(proposalId: bigint, support: number): Promise<any>;
    castVoteBySig(proposalId: bigint, support: number, voter: AddressLike, sig: BytesLike): Promise<bigint>;
    castVoteWithReason(proposalId: bigint, support: number, reason: string): Promise<bigint>;
    castVoteWithReasonAndParams(proposalId: bigint, support: number, reason: string, params: BytesLike): Promise<bigint>;
    castVoteWithReasonAndParamsBySig(proposalId: bigint, support: number, reason: string, params: BytesLike, sig: BytesLike): Promise<bigint>;
    execute(targets: AddressLike[], values: bigint[], calldatas: BytesLike[], proposalDescription: BytesLike): Promise<bigint>;
    fireCanceller(fired: AddressLike): Promise<any>;
    grantRole(role: BytesLike, account: AddressLike): Promise<any>;
    propose(targets: AddressLike[], values: bigint[], calldatas: BytesLike[], description: string): Promise<bigint>;
    queue(targets: AddressLike[], values: bigint[], calldatas: BytesLike[], proposalDescription: BytesLike): Promise<bigint>;
    rejectProposalAction(proposalId: bigint): Promise<any>;
    relay(target: AddressLike, value: bigint, data: BytesLike): Promise<any>;
    renounceRole(role: BytesLike, callerConfirmation: AddressLike): Promise<any>;
    revokeRole(role: BytesLike, account: AddressLike): Promise<any>;
    setProposalThreshold(newProposalThreshold: bigint): Promise<any>;
    setVotingDelay(newVotingDelay: number): Promise<any>;
    setVotingPeriod(newVotingPeriod: number): Promise<any>;
    swapRoles(formerCancellers: AddressLike[], newCancellers: AddressLike[]): Promise<any>;
    changeRunner(runner: ContractRunner): Promise<any>;
    updateQuorumNumerator(newQuorumNumerator: bigint): Promise<any>;
    updateTimelock(newTimelock: AddressLike): Promise<any>;
}

declare class BaseCoder {
    protected address: string;
    protected interface: Interface;
    constructor(address: string, iface: Interface);
    decode(targets: string[], calldatas: string[]): {
        index: number;
        functionName: string;
        params: any[];
    }[];
}

declare class Coder$4 extends BaseCoder {
    constructor(address: string, iface: Interface);
}

/**
 * Represents a Governor contract.
 * Provides methods for interacting with governance-related functions,
 * including event handling, fetching data, viewing state, executing transactions,
 * and encoding/decoding data.
 */
declare class Governor {
    events: Events$4;
    fetch: Fetch$4;
    exec: Execute$2;
    coder: Coder$4;
    contract: Contract;
    interface: Interface;
    constructor(address: string, runner: ContractRunner, abi?: any);
}

interface ApprovalEvent$1 {
    owner: string;
    spender: string;
    value: bigint;
    payload: any;
}
interface DelegateChangedEvent {
    delegator: string;
    fromDelegate: string;
    toDelegate: string;
    payload: any;
}
interface DelegateVotesChangedEvent {
    delegate: string;
    previousBalance: bigint;
    newBalance: bigint;
    payload: any;
}
interface TransferEvent$1 {
    from: string;
    to: string;
    value: bigint;
    payload: any;
}
interface MintEvent$1 {
    to: string;
    value: bigint;
    payload: any;
}
interface EIP712DomainChangedEvent$1 {
    payload: any;
}
interface TokenEvents {
    Approval: ApprovalEvent$1;
    DelegateChanged: DelegateChangedEvent;
    DelegateVotesChanged: DelegateVotesChangedEvent;
    Transfer: TransferEvent$1;
    Mint: MintEvent$1;
    EIP712DomainChanged: EIP712DomainChangedEvent$1;
}

declare class Events$3 extends BaseEvents<TokenEvents> {
    constructor(contract: Contract);
    approval(callback: EventCallback<TokenEvents["Approval"]>): Promise<void>;
    delegateChanged(callback: EventCallback<TokenEvents["DelegateChanged"]>): Promise<void>;
    delegateVotesChanged(callback: EventCallback<TokenEvents["DelegateVotesChanged"]>): Promise<void>;
    mint(callback: EventCallback<TokenEvents["Mint"]>): Promise<void>;
    transfer(callback: EventCallback<TokenEvents["Transfer"]>): Promise<void>;
    eip712DomainChanged(callback: EventCallback<TokenEvents["EIP712DomainChanged"]>): Promise<void>;
}

declare class Fetch$3 {
    private contract;
    constructor(contract: Contract);
    approval(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    delegateChanged(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    delegateVotesChanged(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    transfer(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    domainChanged(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    domainSeparator(): Promise<BytesLike>;
    clockMode(): Promise<string>;
    allowance(owner: AddressLike, spender: AddressLike): Promise<bigint>;
    balanceOf(account: AddressLike): Promise<bigint>;
    checkpoints(account: AddressLike, pos: number): Promise<any>;
    clock(): Promise<number>;
    decimals(): Promise<number>;
    delegates(account: AddressLike): Promise<AddressLike>;
    domain(): Promise<any>;
    getPastTotalSupply(timepoint: bigint): Promise<bigint>;
    getPastVotes(account: AddressLike, timepoint: bigint): Promise<bigint>;
    getVotes(account: AddressLike): Promise<bigint>;
    name(): Promise<string>;
    symbol(): Promise<string>;
    nonces(owner: AddressLike): Promise<bigint>;
    numCheckpoints(account: AddressLike): Promise<number>;
    totalSupply(): Promise<bigint>;
    changeRunner(runner: ContractRunner): void;
}

declare class Execute$1 {
    private contract;
    constructor(contract: Contract);
    approve(spender: AddressLike, value: bigint): Promise<boolean>;
    delegate(delegatee: AddressLike): Promise<any>;
    delegateBySig(delegatee: AddressLike, nonce: bigint, expiry: bigint, v: number, r: BytesLike, s: BytesLike): Promise<any>;
    permit(): Promise<any>;
    transfer(to: AddressLike, value: bigint): Promise<boolean>;
    transferFrom(from: AddressLike, to: AddressLike, value: bigint): Promise<boolean>;
    changeRunner(runner: ContractRunner): void;
}

declare class Coder$3 extends BaseCoder {
    constructor(address: string, iface: Interface);
}

/**
 * Represents an ERC20 token contract.
 * Provides methods for interacting with the token contract, including events, fetching data,
 * viewing contract state, and executing transactions.
 */
declare class Token {
    events: Events$3;
    fetch: Fetch$3;
    exec: Execute$1;
    coder: Coder$3;
    contract: Contract;
    interface: Interface;
    constructor(address: string, runner: ContractRunner, abi?: ({
        inputs: {
            internalType: string;
            name: string;
            type: string;
        }[];
        stateMutability: string;
        type: string;
        name?: undefined;
        anonymous?: undefined;
        outputs?: undefined;
    } | {
        inputs: {
            internalType: string;
            name: string;
            type: string;
        }[];
        name: string;
        type: string;
        stateMutability?: undefined;
        anonymous?: undefined;
        outputs?: undefined;
    } | {
        anonymous: boolean;
        inputs: {
            indexed: boolean;
            internalType: string;
            name: string;
            type: string;
        }[];
        name: string;
        type: string;
        stateMutability?: undefined;
        outputs?: undefined;
    } | {
        inputs: {
            internalType: string;
            name: string;
            type: string;
        }[];
        name: string;
        outputs: {
            internalType: string;
            name: string;
            type: string;
        }[];
        stateMutability: string;
        type: string;
        anonymous?: undefined;
    } | {
        inputs: {
            internalType: string;
            name: string;
            type: string;
        }[];
        name: string;
        outputs: {
            components: {
                internalType: string;
                name: string;
                type: string;
            }[];
            internalType: string;
            name: string;
            type: string;
        }[];
        stateMutability: string;
        type: string;
        anonymous?: undefined;
    })[]);
}

interface CallExecutedEvent {
    id: string;
    index: bigint;
    target: string;
    value: bigint;
    data: string;
    payload: any;
}
interface CallSaltEvent {
    id: string;
    salt: string;
    payload: any;
}
interface CallScheduledEvent {
    id: string;
    index: bigint;
    target: string;
    value: bigint;
    data: string;
    predecessor: string;
    delay: bigint;
    payload: any;
}
interface CancelledEvent {
    id: string;
    payload: any;
}
interface MinDelayChangeEvent {
    oldDuration: bigint;
    newDuration: bigint;
    payload: any;
}
interface RoleAdminChangedEvent$1 {
    role: string;
    previousAdminRole: string;
    newAdminRole: string;
    payload: any;
}
interface RoleGrantedEvent$1 {
    role: string;
    account: string;
    sender: string;
    payload: any;
}
interface RoleRevokedEvent {
    role: string;
    account: string;
    sender: string;
    payload: any;
}
interface TimelockEvents {
    CallExecuted: CallExecutedEvent;
    CallSalt: CallSaltEvent;
    CallScheduled: CallScheduledEvent;
    Cancelled: CancelledEvent;
    MinDelayChange: MinDelayChangeEvent;
    RoleAdminChanged: RoleAdminChangedEvent$1;
    RoleGranted: RoleGrantedEvent$1;
    RoleRevoked: RoleRevokedEvent;
}

declare class Events$2 extends BaseEvents<TimelockEvents> {
    constructor(contract: Contract);
    callExecuted(callback: EventCallback<TimelockEvents["CallExecuted"]>): Promise<void>;
    callSalt(callback: EventCallback<TimelockEvents["CallSalt"]>): Promise<void>;
    callScheduled(callback: EventCallback<TimelockEvents["CallScheduled"]>): Promise<void>;
    cancelled(callback: EventCallback<TimelockEvents["Cancelled"]>): Promise<void>;
    minDelayChange(callback: EventCallback<TimelockEvents["MinDelayChange"]>): Promise<void>;
    roleAdminChanged(callback: EventCallback<TimelockEvents["RoleAdminChanged"]>): Promise<void>;
    roleGranted(callback: EventCallback<TimelockEvents["RoleGranted"]>): Promise<void>;
    roleRevoked(callback: EventCallback<TimelockEvents["RoleRevoked"]>): Promise<void>;
}

declare class Fetch$2 {
    private contract;
    constructor(contract: Contract);
    callExecuted(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    callSalt(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    callScheduled(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    cancelled(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    minDelayChange(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    roleAdminChanged(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    roleGranted(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    roleRevoked(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    executorRole(): Promise<BytesLike>;
    defaultAdminRole(): Promise<BytesLike>;
    getMinDelay(): Promise<bigint>;
    getOperationState(id: BytesLike): Promise<number>;
    getRoleAdmin(role: BytesLike): Promise<BytesLike>;
    getTimestamp(id: BytesLike): Promise<bigint>;
    hasRole(role: BytesLike, account: AddressLike): Promise<boolean>;
    isOperation(id: BytesLike): Promise<boolean>;
    isOperationDone(id: BytesLike): Promise<boolean>;
    isOperationPending(id: BytesLike): Promise<boolean>;
    isOperationReady(id: BytesLike): Promise<boolean>;
    supportsInterface(interfaceId: BytesLike): Promise<boolean>;
    changeRunner(runner: ContractRunner): void;
}

declare class Execute {
    private contract;
    constructor(contract: Contract);
    cancel(id: BytesLike): Promise<any>;
    execute(target: AddressLike, value: bigint, payload: BytesLike, predecessor: BytesLike, salt: BytesLike): Promise<any>;
    executeBatch(targets: AddressLike[], values: bigint[], payloads: BytesLike[], predecessor: BytesLike, salt: BytesLike): Promise<any>;
    grantRole(role: BytesLike, account: AddressLike): Promise<any>;
    renounceRole(role: BytesLike, callerConfirmation: AddressLike): Promise<any>;
    revokeRole(role: BytesLike, account: AddressLike): Promise<any>;
    schedule(target: AddressLike, value: bigint, data: BytesLike, predecessor: BytesLike, salt: BytesLike, delay: bigint): Promise<any>;
    scheduleBatch(targets: AddressLike[], values: bigint[], data: BytesLike[], predecessor: BytesLike, salt: BytesLike, delay: bigint): Promise<any>;
    updateDelay(newDelay: bigint): Promise<any>;
    changeRunner(runner: ContractRunner): void;
}

declare class Coder$2 extends BaseCoder {
    constructor(address: string, iface: Interface);
}

/**
 * Represents the Timelock contract.
 * This class provides access to events, fetching data, viewing state, and executing transactions on the Timelock contract.
 */
declare class Timelock {
    events: Events$2;
    fetch: Fetch$2;
    exec: Execute;
    coder: Coder$2;
    contract: Contract;
    interface: Interface;
    constructor(address: string, runner: ContractRunner, abi?: ({
        inputs: {
            internalType: string;
            name: string;
            type: string;
        }[];
        stateMutability: string;
        type: string;
        name?: undefined;
        anonymous?: undefined;
        outputs?: undefined;
    } | {
        inputs: {
            internalType: string;
            name: string;
            type: string;
        }[];
        name: string;
        type: string;
        stateMutability?: undefined;
        anonymous?: undefined;
        outputs?: undefined;
    } | {
        anonymous: boolean;
        inputs: {
            indexed: boolean;
            internalType: string;
            name: string;
            type: string;
        }[];
        name: string;
        type: string;
        stateMutability?: undefined;
        outputs?: undefined;
    } | {
        inputs: {
            internalType: string;
            name: string;
            type: string;
        }[];
        name: string;
        outputs: {
            internalType: string;
            name: string;
            type: string;
        }[];
        stateMutability: string;
        type: string;
        anonymous?: undefined;
    } | {
        stateMutability: string;
        type: string;
        inputs?: undefined;
        name?: undefined;
        anonymous?: undefined;
        outputs?: undefined;
    })[]);
}

interface ApprovalEvent {
    owner: string;
    approved: string;
    tokenId: bigint;
    payload: any;
}
interface ApprovalForAllEvent {
    owner: string;
    operator: string;
    approved: boolean;
    payload: any;
}
interface OwnershipTransferredEvent {
    previousOwner: string;
    newOwner: string;
    payload: any;
}
interface TransferEvent {
    from: string;
    to: string;
    tokenId: bigint;
    payload: any;
}
interface MintEvent {
    to: string;
    tokenId: bigint;
    payload: any;
}
interface NFTEvents {
    Approval: ApprovalEvent;
    ApprovalForAll: ApprovalForAllEvent;
    OwnershipTransferred: OwnershipTransferredEvent;
    Transfer: TransferEvent;
    Mint: MintEvent;
}

declare class Events$1 extends BaseEvents<NFTEvents> {
    constructor(contract: Contract);
    approval(callback: EventCallback<NFTEvents["Approval"]>): Promise<void>;
    approvalForAll(callback: EventCallback<NFTEvents["ApprovalForAll"]>): Promise<void>;
    ownershipTransferred(callback: EventCallback<NFTEvents["OwnershipTransferred"]>): Promise<void>;
    mint(callback: EventCallback<NFTEvents["Mint"]>): Promise<void>;
    transfer(callback: EventCallback<NFTEvents["Transfer"]>): Promise<void>;
}

declare class Fetch$1 {
    private contract;
    constructor(contract: Contract);
    approval(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    approvalForAll(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    ownershipTransfered(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    transfer(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    max(): Promise<BytesLike>;
    getApproved(tokenId: bigint): Promise<AddressLike>;
    isApprovedForAll(owner: AddressLike, operator: AddressLike): Promise<boolean>;
    balanceOf(account: AddressLike): Promise<bigint>;
    name(): Promise<string>;
    owner(): Promise<AddressLike>;
    symbol(): Promise<string>;
    tokenByIndex(index: bigint): Promise<bigint>;
    tokenOfOwnerByIndex(owner: AddressLike, index: bigint): Promise<bigint>;
    tokenURI(tokenId: bigint): Promise<string>;
    totalSupply(): Promise<bigint>;
    changeRunner(runner: ContractRunner): void;
}

declare class Coder$1 extends BaseCoder {
    constructor(address: string, iface: Interface);
}

/**
 * Represents an NFT (Non-Fungible Token) contract.
 * Provides methods for interacting with events, fetching data,
 * and viewing contract state.
 */
declare class NFT {
    events: Events$1;
    fetch: Fetch$1;
    coder: Coder$1;
    contract: Contract;
    interface: Interface;
    constructor(address: string, runner: ContractRunner, abi?: ({
        inputs: {
            internalType: string;
            name: string;
            type: string;
        }[];
        stateMutability: string;
        type: string;
        anonymous?: undefined;
        name?: undefined;
        outputs?: undefined;
    } | {
        anonymous: boolean;
        inputs: {
            indexed: boolean;
            internalType: string;
            name: string;
            type: string;
        }[];
        name: string;
        type: string;
        stateMutability?: undefined;
        outputs?: undefined;
    } | {
        inputs: {
            internalType: string;
            name: string;
            type: string;
        }[];
        name: string;
        outputs: {
            internalType: string;
            name: string;
            type: string;
        }[];
        stateMutability: string;
        type: string;
        anonymous?: undefined;
    })[]);
}

interface NFTBoughtEvent {
    buyer: string;
    seller: string;
    nftAddress: string;
    tokenId: bigint;
    price: bigint;
    payload: any;
}
interface GameItemReadyEvent {
    owner: string;
    tokenId: bigint;
    payload: any;
}
interface EIP712DomainChangedEvent {
    payload: any;
}
interface FeeChangedEvent {
    oldFee: bigint;
    newFee: bigint;
    payload: any;
}
interface RoleAdminChangedEvent {
    role: string;
    previousAdminRole: string;
    newAdminRole: string;
    payload: any;
}
interface RoleGrantedEvent {
    role: string;
    account: string;
    sender: string;
    payload: any;
}
interface MarketplaceEvents {
    NFTBought: NFTBoughtEvent;
    GameItemReady: GameItemReadyEvent;
    EIP712DomainChanged: EIP712DomainChangedEvent;
    FeeChanged: FeeChangedEvent;
    RoleAdminChanged: RoleAdminChangedEvent;
    RoleGranted: RoleGrantedEvent;
}

declare class Events extends BaseEvents<MarketplaceEvents> {
    constructor(contract: Contract);
    nftBought(callback: EventCallback<MarketplaceEvents["NFTBought"]>): Promise<void>;
    gameItemReady(callback: EventCallback<MarketplaceEvents["GameItemReady"]>): Promise<void>;
    eip712DomainChanged(callback: EventCallback<MarketplaceEvents["EIP712DomainChanged"]>): Promise<void>;
    feeChanged(callback: EventCallback<MarketplaceEvents["FeeChanged"]>): Promise<void>;
    roleAdminChanged(callback: EventCallback<MarketplaceEvents["RoleAdminChanged"]>): Promise<void>;
    roleGranted(callback: EventCallback<MarketplaceEvents["RoleGranted"]>): Promise<void>;
}

declare class Fetch {
    private contract;
    constructor(contract: Contract);
    nftBought(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    gameItemReady(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    domainChanged(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    feeChanged(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    roleAdminChanged(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    roleGranted(from?: BlockTag, to?: BlockTag): Promise<(EventLog | Log)[]>;
    changeRunner(runner: ContractRunner): void;
}

declare class Coder extends BaseCoder {
    constructor(address: string, iface: Interface);
}

/**
 * Represents the Marketplace contract interface.
 * Provides access to events, fetch operations, and view functions of the marketplace.
 */
declare class Marketplace {
    events: Events;
    fetch: Fetch;
    coder: Coder;
    contract: Contract;
    interface: Interface;
    constructor(address: string, runner: ContractRunner, abi?: ({
        inputs: {
            internalType: string;
            name: string;
            type: string;
        }[];
        stateMutability: string;
        type: string;
        name?: undefined;
        anonymous?: undefined;
        outputs?: undefined;
    } | {
        inputs: {
            internalType: string;
            name: string;
            type: string;
        }[];
        name: string;
        type: string;
        stateMutability?: undefined;
        anonymous?: undefined;
        outputs?: undefined;
    } | {
        anonymous: boolean;
        inputs: {
            indexed: boolean;
            internalType: string;
            name: string;
            type: string;
        }[];
        name: string;
        type: string;
        stateMutability?: undefined;
        outputs?: undefined;
    } | {
        inputs: {
            internalType: string;
            name: string;
            type: string;
        }[];
        name: string;
        outputs: {
            internalType: string;
            name: string;
            type: string;
        }[];
        stateMutability: string;
        type: string;
        anonymous?: undefined;
    })[]);
}

/**
 * AMGI class representing AMGI Studios LLC. Ethereum ecosystem.
 * This class provides access to various components of the AMGI ecosystem,
 * including governance, token, timelock, marketplace, and NFT contracts.
 */
declare class AMGI {
    winvote: Governor;
    timelock: Timelock;
    karrat: Token;
    market: Marketplace;
    hooligans: NFT;
    zuckbots: NFT;
    constructor(winvoteAddress: string, karratAddress: string, timelockAddress: string, marketAddress: string, hooliganAddress: string, zuckbotAddress: string, runner: ContractRunner);
}

export { AMGI, Governor, Marketplace, NFT, Timelock, Token };