/**
 * TypedContract type definitions for ethers v6 with abitype.
 *
 * This is a local copy of types from ethers-abitype to avoid the global
 * abitype module augmentation that pollutes AddressType with `string | Addressable`,
 * which breaks viem type compatibility.
 *
 * @see https://github.com/ethers-io/ethers.js/issues/4475
 */
import type { BaseContract, ContractTransaction, ContractTransactionResponse, DeferredTopicFilter, EventFragment, FunctionFragment, Result, Overrides } from 'ethers';
import type { Abi, AbiParametersToPrimitiveTypes, ExtractAbiEvent, ExtractAbiEventNames, ExtractAbiEvents, ExtractAbiFunction, ExtractAbiFunctionNames, ExtractAbiFunctions } from 'abitype';
type AsArray<T> = T extends readonly unknown[] ? T : never;
export type TypedContractFunctionResult<TAbi extends Abi, TFunctionName extends string, TOutputArgs = AbiParametersToPrimitiveTypes<ExtractAbiFunction<TAbi, TFunctionName>['outputs']>> = TOutputArgs extends readonly [] ? void : TOutputArgs extends readonly [infer Arg] ? Arg : TOutputArgs;
export type TypedFragment<TAbi extends Abi, TFunctionName extends string, TFunction extends ExtractAbiFunctions<TAbi> = ExtractAbiFunction<TAbi, TFunctionName>> = Omit<FunctionFragment, 'inputs' | 'outputs' | 'stateMutability' | 'name' | 'type'> & {
    name: TFunction['name'];
    type: TFunction['type'];
    inputs: TFunction['inputs'];
    outputs: TFunction['outputs'];
    stateMutability: TFunction['stateMutability'];
};
export interface TypedContractFunction<TAbi extends Abi, TFunctionName extends string, TFunction extends ExtractAbiFunctions<TAbi> = ExtractAbiFunction<TAbi, TFunctionName>, TInputArgs extends readonly unknown[] = AsArray<AbiParametersToPrimitiveTypes<TFunction['inputs']>>, TResult = TypedContractFunctionResult<TAbi, TFunctionName>, TFragment = TypedFragment<TAbi, TFunctionName>> {
    (...args: [...TInputArgs, overrides?: Overrides]): Promise<TFunction['stateMutability'] extends 'view' | 'pure' ? TResult : ContractTransactionResponse>;
    /**
     * The name of the Contract method.
     */
    name: TFunctionName;
    /**
     * The fragment of the Contract method. This will throw on ambiguous
     * method names.
     */
    fragment: TFragment;
    /**
     * Returns the fragment constrained by %%args%%. This can be used to
     * resolve ambiguous method names.
     */
    getFragment(...args: [...TInputArgs]): TFragment;
    /**
     * Returns a populated transaction that can be used to perform the
     * contract method with %%args%%.
     */
    populateTransaction(...args: [...TInputArgs, overrides?: Overrides]): Promise<ContractTransaction>;
    /**
     * Call the contract method with %%args%% and return the value.
     *
     * If the return value is a single type, it will be dereferenced and
     * returned directly, otherwise the full Result will be returned.
     */
    staticCall(...args: [...TInputArgs, overrides?: Overrides]): Promise<TResult>;
    /**
     * Send a transaction for the contract method with %%args%%.
     */
    send(...args: [...TInputArgs, overrides?: Overrides]): Promise<ContractTransactionResponse>;
    /**
     * Estimate the gas to send the contract method with %%args%%.
     */
    estimateGas(...args: [...TInputArgs, overrides?: Overrides]): Promise<bigint>;
    /**
     * Call the contract method with %%args%% and return the Result
     * without any dereferencing.
     */
    staticCallResult(...args: [...TInputArgs, overrides?: Overrides]): Promise<Result>;
}
export interface TypedContractEvent<TAbi extends Abi, TEventName extends string, TEvent extends ExtractAbiEvents<TAbi> = ExtractAbiEvent<TAbi, TEventName>, TEventArgs extends readonly unknown[] = AsArray<Partial<AbiParametersToPrimitiveTypes<TEvent['inputs']>>>> {
    (...args: [...TEventArgs]): DeferredTopicFilter;
    /**
     * The name of the Contract event.
     */
    name: TEventName;
    /**
     * The fragment of the Contract event. This will throw on ambiguous
     * method names.
     */
    fragment: EventFragment;
    /**
     * Returns the fragment constrained by %%args%%. This can be used to
     * resolve ambiguous event names.
     */
    getFragment(...args: [...TEventArgs]): EventFragment;
}
export type TypedContract<TAbi extends Abi> = Omit<BaseContract, 'getFunction' | 'getEvent'> & {
    [Method in ExtractAbiFunctionNames<TAbi>]: TypedContractFunction<TAbi, Method>;
} & {
    /**
     * Return the function for a given name. This is useful when a contract
     * method name conflicts with a JavaScript name such as ``prototype`` or
     * when using a Contract programatically.
     */
    getFunction<T extends ExtractAbiFunctionNames<TAbi>>(key: T | TypedFragment<TAbi, T>): TypedContractFunction<TAbi, T>;
    /**
     * Return the event for a given name. This is useful when a contract
     * event name conflicts with a JavaScript name such as ``prototype`` or
     * when using a Contract programatically.
     */
    getEvent<T extends ExtractAbiEventNames<TAbi>>(key: T | EventFragment): TypedContractEvent<TAbi, T>;
    /**
     * All the Events available on this contract.
     */
    filters: {
        [EventName in ExtractAbiEventNames<TAbi>]: TypedContractEvent<TAbi, EventName>;
    };
};
export {};