import { ResolvedConfig } from './config';
export type CairoFelt = 'core::felt252';
type MBits = 8 | 16 | 32;
type BigMBits = 64 | 128;
export type CairoInt = `${'core::integer::u'}${MBits}`;
export type CairoBigInt = `${'core::integer::u'}${BigMBits}`;
export type CairoU256 = 'core::integer::u256';
export type CairoU512 = 'core::integer::u512';
export type CairoContractAddress = 'core::starknet::contract_address::ContractAddress';
export type CairoEthAddress = 'core::starknet::eth_address::EthAddress';
export type CairoClassHash = 'core::starknet::class_hash::ClassHash';
export type CairoFunction = 'function';
export type CairoVoid = '()';
export type CairoBool = 'core::bool';
export type CairoBytes31 = 'core::bytes_31::bytes31';
export type CairoByteArray = 'core::byte_array::ByteArray';
export type CairoSecp256k1Point = 'core::starknet::secp256k1::Secp256k1Point';
type MAX_TUPLE_SIZE = 20;
type _BuildTuple<R extends unknown = never, A extends string = '', D extends readonly number[] = []> = D['length'] extends MAX_TUPLE_SIZE ? `${A})` | R : A extends '' ? _BuildTuple<R, `(${string}`, [...D, 1]> : _BuildTuple<`${A})` | R, `${A}, ${string}`, [...D, 1]>;
export type CairoTuple = _BuildTuple;
type AbiType = CairoFelt | CairoFunction | CairoInt | CairoBigInt | CairoU256 | CairoU512 | CairoContractAddress | CairoEthAddress | CairoClassHash | CairoBool | CairoVoid | CairoBytes31 | CairoByteArray | CairoSecp256k1Point;
type CairoOptionGeneric<T extends string> = `core::option::Option::<${T}>`;
type CairoArrayGeneric<T extends string> = `core::array::Array::<${T}>` | `core::array::Span::<${T}>`;
type CairoResultGeneric<T extends string, E extends string> = `core::result::Result::<${T}, ${E}>`;
type CairoGeneric<T extends string, E extends string> = CairoOptionGeneric<T> | CairoArrayGeneric<T> | CairoResultGeneric<T, E>;
export type Option<T> = ResolvedConfig<T>['Option'];
export type Tuple = ResolvedConfig['Tuple'];
export type Result<T, E> = ResolvedConfig<any, T, E>['Result'];
export type Enum = ResolvedConfig['Enum'];
export type Calldata = ResolvedConfig['Calldata'];
export type InvokeOptions = ResolvedConfig['InvokeOptions'];
export type CallOptions = ResolvedConfig['CallOptions'];
export type InvokeFunctionResponse = ResolvedConfig['InvokeFunctionResponse'];
export type Call = ResolvedConfig['Call'];
type AbiParameter = {
    name: string;
    type: string;
};
type AbiOutput = {
    type: string;
};
type AbiStateMutability = 'view' | 'external';
type AbiImpl = {
    type: 'impl';
    name: string;
    interface_name: string;
};
type AbiInterface = {
    type: 'interface';
    name: string;
    items: readonly AbiFunction[];
};
type AbiConstructor = {
    type: 'constructor';
    name: 'constructor';
    inputs: readonly AbiParameter[];
};
type AbiFunction = {
    type: 'function';
    name: string;
    inputs: readonly AbiParameter[];
    outputs: readonly AbiOutput[];
    state_mutability: AbiStateMutability;
};
type AbiEventKind = 'nested' | 'data' | 'key' | 'flat';
export type AbiEventMember = {
    name: string;
    type: string;
    kind: AbiEventKind;
};
type AbiEventStruct = {
    type: 'event';
    name: string;
    kind: 'struct';
    members: readonly AbiEventMember[];
};
type AbiEventEnum = {
    type: 'event';
    name: string;
    kind: 'enum';
    variants: readonly AbiEventMember[];
};
type AbiEvent = AbiEventStruct | AbiEventEnum;
type AbiMember = {
    name: string;
    type: string;
};
type AbiStruct = {
    type: 'struct';
    name: string;
    members: readonly AbiMember[];
};
type AbiEnum = {
    type: 'enum';
    name: string;
    variants: readonly AbiParameter[];
};
export type Abi = readonly (AbiImpl | AbiInterface | AbiConstructor | AbiFunction | AbiStruct | AbiEnum | AbiEvent)[];
type _BuildArgs<TAbi extends Abi, TAbiParam extends readonly AbiParameter[], R extends unknown[]> = R['length'] extends TAbiParam['length'] ? R : _BuildArgs<TAbi, TAbiParam, [
    ...R,
    StringToPrimitiveType<TAbi, TAbiParam[R['length']]['type']>
]>;
export type FunctionArgs<TAbi extends Abi, TFunctionName extends ExtractAbiFunctionNames<TAbi>> = ExtractAbiFunction<TAbi, TFunctionName>['inputs'] extends readonly [] ? [] : _BuildArgs<TAbi, ExtractAbiFunction<TAbi, TFunctionName>['inputs'], [
]> extends [infer T] ? T : _BuildArgs<TAbi, ExtractAbiFunction<TAbi, TFunctionName>['inputs'], []>;
export type FunctionRet<TAbi extends Abi, TFunctionName extends ExtractAbiFunctionNames<TAbi>> = ExtractAbiFunction<TAbi, TFunctionName>['outputs'] extends readonly [] ? void : StringToPrimitiveType<TAbi, ExtractAbiFunction<TAbi, TFunctionName>['outputs'][0]['type']>;
export type ExtractAbiImpls<TAbi extends Abi> = Extract<TAbi[number], {
    type: 'impl';
}>;
export type ExtractAbiInterfaces<TAbi extends Abi> = Extract<TAbi[number], {
    type: 'interface';
}>;
export type ExtractAbiFunctions<TAbi extends Abi> = Extract<ExtractAbiInterfaces<TAbi>['items'][number], {
    type: 'function';
}> | Extract<TAbi[number], {
    type: 'function';
}>;
export type ExtractAbiFunctionNames<TAbi extends Abi> = ExtractAbiFunctions<TAbi>['name'];
export type ExtractAbiFunction<TAbi extends Abi, TFunctionName extends ExtractAbiFunctionNames<TAbi>> = Extract<ExtractAbiFunctions<TAbi>, {
    name: TFunctionName;
}>;
export type ExtractAbiStructs<TAbi extends Abi> = Extract<TAbi[number], {
    type: 'struct';
}>;
export type ExtractAbiStructNames<TAbi extends Abi> = ExtractAbiStructs<TAbi>['name'];
export type ExtractAbiStruct<TAbi extends Abi, TStructName extends ExtractAbiStructNames<TAbi>> = Extract<ExtractAbiStructs<TAbi>, {
    name: TStructName;
}>;
export type ExtractAbiEnums<TAbi extends Abi> = Extract<TAbi[number], {
    type: 'enum';
}>;
export type ExtractAbiEnumNames<TAbi extends Abi> = ExtractAbiEnums<TAbi>['name'];
export type ExtractAbiEnum<TAbi extends Abi, TEnumName extends ExtractAbiEnumNames<TAbi>> = Extract<ExtractAbiEnums<TAbi>, {
    name: TEnumName;
}>;
export type ExtractAbiEvents<TAbi extends Abi> = Extract<TAbi[number], {
    type: 'event';
}>;
export type ExtractAbiEventNames<TAbi extends Abi> = ExtractAbiEvents<TAbi>['name'];
export type ExtractAbiEvent<TAbi extends Abi, TEventName extends ExtractAbiEventNames<TAbi>> = Extract<ExtractAbiEvents<TAbi>, {
    name: TEventName;
}>;
type PrimitiveTypeLookup<TAbi extends Abi> = {
    [_ in CairoFelt]: ResolvedConfig['FeltType'];
} & {
    [_ in CairoFunction]: number;
} & {
    [_ in CairoInt]: ResolvedConfig['IntType'];
} & {
    [_ in CairoU256]: ResolvedConfig['U256Type'];
} & {
    [_ in CairoU512]: ResolvedConfig['U512Type'];
} & {
    [_ in CairoBigInt]: ResolvedConfig['BigIntType'];
} & {
    [_ in CairoContractAddress]: ResolvedConfig['AddressType'];
} & {
    [_ in CairoEthAddress]: ResolvedConfig['AddressType'];
} & {
    [_ in CairoClassHash]: ResolvedConfig['ClassHashType'];
} & {
    [_ in CairoVoid]: void;
} & {
    [_ in CairoBool]: boolean;
} & {
    [_ in CairoBytes31]: ResolvedConfig['Bytes31Type'];
} & {
    [_ in CairoByteArray]: ResolvedConfig['ByteArray'];
} & {
    [_ in CairoSecp256k1Point]: ResolvedConfig['Secp256k1PointType'];
};
export type AbiTypeToPrimitiveType<TAbi extends Abi, TAbiType extends AbiType> = PrimitiveTypeLookup<TAbi>[TAbiType];
export type GenericTypeToPrimitiveType<TAbi extends Abi, G extends string> = G extends CairoOptionGeneric<infer T> ? T extends AbiType ? Option<AbiTypeToPrimitiveType<TAbi, T>> : Option<StringToPrimitiveType<TAbi, T>> : G extends CairoArrayGeneric<infer T> ? T extends AbiType ? AbiTypeToPrimitiveType<TAbi, T>[] : StringToPrimitiveType<TAbi, T>[] : G extends CairoResultGeneric<infer T, infer E> ? T extends AbiType ? E extends AbiType ? Result<AbiTypeToPrimitiveType<TAbi, T>, AbiTypeToPrimitiveType<TAbi, E>> : Result<AbiTypeToPrimitiveType<TAbi, T>, StringToPrimitiveType<TAbi, E>> : Result<StringToPrimitiveType<TAbi, T>, StringToPrimitiveType<TAbi, E>> : unknown;
export type CairoTupleToPrimitive<TAbi extends Abi, T extends string> = T extends `(${infer first}, ${infer remaining})` ? [
    StringToPrimitiveType<TAbi, first>,
    ...CairoTupleToPrimitive<TAbi, `(${remaining})`>
] : T extends `(${infer first})` ? [StringToPrimitiveType<TAbi, first>] : [unknown];
type ObjectToUnion<T extends Record<string, any>> = {
    [K in keyof T]: {
        [Key in K]: T[K];
    };
}[keyof T];
export type EventToPrimitiveType<TAbi extends Abi, TEventName extends ExtractAbiEventNames<TAbi>> = ExtractAbiEvent<TAbi, TEventName> extends {
    type: 'event';
    kind: 'struct';
    members: infer TMembers extends readonly AbiEventMember[];
} ? {
    [Member in TMembers[number] as Member['name']]: StringToPrimitiveType<TAbi, Member['type']>;
} : ExtractAbiEvent<TAbi, TEventName> extends {
    type: 'event';
    kind: 'enum';
    variants: infer TVariants extends readonly AbiEventMember[];
} ? ObjectToUnion<{
    [Variant in TVariants[number] as Variant['name']]: StringToPrimitiveType<TAbi, Variant['type']>;
}> : never;
export type StringToPrimitiveTypeS<TAbi extends Abi, T extends string> = ExtractAbiEnum<TAbi, T>;
export type StringToPrimitiveType<TAbi extends Abi, T extends string> = T extends AbiType ? AbiTypeToPrimitiveType<TAbi, T> : T extends CairoGeneric<infer _, infer _> ? GenericTypeToPrimitiveType<TAbi, T> : T extends CairoTuple ? Tuple extends never ? CairoTupleToPrimitive<TAbi, T> : Tuple : ExtractAbiStruct<TAbi, T> extends never ? ExtractAbiEnum<TAbi, T> extends never ? unknown : Enum extends never ? ExtractAbiEnum<TAbi, T> extends {
    type: 'enum';
    variants: infer TVariants extends readonly AbiParameter[];
} ? ObjectToUnion<{
    [Variant in TVariants[number] as Variant['name']]: StringToPrimitiveType<TAbi, Variant['type']>;
}> : never : Enum : ExtractAbiStruct<TAbi, T> extends {
    type: 'struct';
    members: infer TMembers extends readonly AbiMember[];
} ? {
    [Member in TMembers[number] as Member['name']]: StringToPrimitiveType<TAbi, Member['type']>;
} : never;
export type FunctionCallWithCallData<TAbi extends Abi, TAbiFunction extends AbiFunction> = (calldata: Calldata) => TAbiFunction['state_mutability'] extends 'view' ? Promise<FunctionRet<TAbi, TAbiFunction['name']>> : InvokeFunctionResponse;
export type ExtractArgs<TAbi extends Abi, TAbiFunction extends AbiFunction> = TAbiFunction['inputs'] extends infer TInput extends readonly AbiParameter[] ? {
    [K3 in keyof TInput]: TInput[K3] extends infer TInputParam extends AbiParameter ? StringToPrimitiveType<TAbi, TInputParam['type']> : never;
} : never;
export type FunctionCallWithArgs<TAbi extends Abi, TAbiFunction extends AbiFunction> = (...args: ExtractArgs<TAbi, TAbiFunction>) => TAbiFunction['state_mutability'] extends 'view' ? Promise<FunctionRet<TAbi, TAbiFunction['name']>> : InvokeFunctionResponse;
export type FunctionCallWithOptions<TAbi extends Abi, TAbiFunction extends AbiFunction> = TAbiFunction['state_mutability'] extends 'view' ? (...args: [...ExtractArgs<TAbi, TAbiFunction>, CallOptions]) => Promise<FunctionRet<TAbi, TAbiFunction['name']>> : (...args: [...ExtractArgs<TAbi, TAbiFunction>, InvokeOptions]) => InvokeFunctionResponse;
export type FunctionCall<TAbi extends Abi, TAbiFunction extends AbiFunction> = FunctionCallWithArgs<TAbi, TAbiFunction> & FunctionCallWithCallData<TAbi, TAbiFunction> & FunctionCallWithOptions<TAbi, TAbiFunction>;
export type ContractFunctions<TAbi extends Abi> = {
    [K in ExtractAbiFunctionNames<TAbi>]: FunctionCall<TAbi, ExtractAbiFunction<TAbi, K>>;
};
export type FunctionPopulateTransaction<TAbi extends Abi, TAbiFunction extends AbiFunction> = (...args: [...ExtractArgs<TAbi, TAbiFunction>]) => Call;
export type ContractFunctionsPopulateTransaction<TAbi extends Abi> = {
    [K in ExtractAbiFunctionNames<TAbi>]: FunctionPopulateTransaction<TAbi, ExtractAbiFunction<TAbi, K>>;
};
export {};
//# sourceMappingURL=kanabi.d.ts.map