import { StdSignDoc } from "@keplr-wallet/types";
import { OfflineSigner } from "@cosmjs/proto-signing";
import { AccountAddress, ChainId, EvmChainId } from "@injectivelabs/ts-types";
import { TxClientInclusionOptions, TxResponse } from "@injectivelabs/sdk-ts/core/tx";
import { AminoSignResponse, DirectSignResponse, TxRaw } from "@injectivelabs/sdk-ts/types";

//#region src/types/events.d.ts
declare const StrategyEventType: {
  readonly ConnectionEnd: "connection-end";
  readonly ConnectionStart: "connection-start";
  readonly WalletSigningEnd: "wallet-signing-end";
  readonly WalletSigningStart: "wallet-signing-start";
};
declare const WalletConnectStrategyEventType: {
  readonly WalletConnectSigningWithTxTimeout: "signing-with-tx-timeout";
};
declare const WalletStrategyEmitterEventType: {
  readonly TransactionFail: "transaction-fail";
  readonly TransactionSigned: "transaction-signed";
  readonly TransactionSignStart: "transaction-sign-start";
  readonly TransactionBroadcastEnd: "transaction-broadcast-end";
  readonly TransactionBroadcastStart: "transaction-broadcast-start";
  readonly TransactionBroadcastSynced: "transaction-broadcast-synced";
  readonly TransactionPreparationEnd: "transaction-preparation-end";
  readonly TransactionPreparationStart: "transaction-preparation-start";
  readonly WalletStrategyDisconnect: "wallet-strategy-disconnect";
};
type StrategyEventType = (typeof StrategyEventType)[keyof typeof StrategyEventType] | (typeof WalletConnectStrategyEventType)[keyof typeof WalletConnectStrategyEventType];
type WalletStrategyEmitterEventType = (typeof WalletStrategyEmitterEventType)[keyof typeof WalletStrategyEmitterEventType] | StrategyEventType;
type WalletStrategyEmitterEvents = { [K in WalletStrategyEmitterEventType]: Record<string, any> };
interface WalletStrategyEmitter {
  on(event: WalletStrategyEmitterEventType, listener: (...args: any[]) => void): this;
  off(event: WalletStrategyEmitterEventType, listener: (...args: any[]) => void): this;
  emit(event: WalletStrategyEmitterEventType, ...args: any[]): boolean;
}
//#endregion
//#region src/types/enums.d.ts
declare const BroadcastMode: {
  readonly Block: "block";
  readonly Sync: "sync";
  readonly Async: "async";
};
type BroadcastMode = (typeof BroadcastMode)[keyof typeof BroadcastMode];
declare const Wallet: {
  readonly Leap: "leap";
  readonly Keplr: "keplr";
  readonly Ninji: "ninji";
  readonly Magic: "magic";
  readonly Rabby: "rabby";
  readonly Ledger: "ledger";
  readonly BitGet: "BitGet";
  readonly OWallet: "owallet";
  readonly Phantom: "phantom";
  readonly Rainbow: "rainbow";
  readonly Turnkey: "turnkey";
  readonly Metamask: "metamask";
  readonly KeplrEvm: "keplr-evm";
  readonly OkxWallet: "okx-wallet";
  readonly PrivateKey: "private-key";
  readonly TrustWallet: "trust-wallet";
  readonly TrezorBip32: "trezor-bip32";
  readonly TrezorBip44: "trezor-bip44";
  readonly Cosmostation: "cosmostation";
  readonly LedgerCosmos: "ledger-cosmos";
  readonly LedgerLegacy: "ledger-legacy";
  readonly WalletConnect: "wallet-connect";
  readonly CosmostationEth: "cosmostation-eth";
  readonly PrivateKeyCosmos: "private-key-cosmos";
};
type Wallet = (typeof Wallet)[keyof typeof Wallet];
declare const MagicProvider: {
  readonly Email: "email";
  readonly Apple: "apple";
  readonly Github: "github";
  readonly Google: "google";
  readonly Discord: "discord";
  readonly Twitter: "twitter";
  readonly Facebook: "facebook";
};
type MagicProvider = (typeof MagicProvider)[keyof typeof MagicProvider];
declare const WalletDeviceType: {
  readonly Mobile: "mobile";
  readonly Other: "other";
  readonly Browser: "browser";
  readonly Hardware: "hardware";
};
type WalletDeviceType = (typeof WalletDeviceType)[keyof typeof WalletDeviceType];
declare const WalletEventListener: {
  readonly AccountChange: "account-change";
  readonly ChainIdChange: "chain-id-change";
};
type WalletEventListener = (typeof WalletEventListener)[keyof typeof WalletEventListener];
declare const EvmWalletProviderErrorCode: {
  readonly InternalError: -32603;
  readonly UserRejectedRequest: 4001;
  readonly UnrecognizedChain: 4902;
};
type EvmWalletProviderErrorCode = (typeof EvmWalletProviderErrorCode)[keyof typeof EvmWalletProviderErrorCode];
declare const WalletAction: {
  readonly GetChainId: "get-chain-id";
  readonly GetAccounts: "get-accounts";
  readonly GetNetworkId: "get-network-id";
  readonly SignArbitrary: "sign-arbitrary";
  readonly SignTransaction: "sign-transaction";
  readonly SendTransaction: "send-transaction";
  readonly SendEvmTransaction: "send-evm-transaction";
  readonly SignEvmTransaction: "sign-evm-transaction";
  readonly GetEvmTransactionReceipt: "get-evm-transaction-receipt";
};
type WalletAction = (typeof WalletAction)[keyof typeof WalletAction];
//#endregion
//#region src/types/strategy.d.ts
interface StrategyEmitter {
  emit(event: string, data?: Record<string, any>): boolean;
}
type onAccountChangeCallback = (account: string | string[]) => void;
type onChainIdChangeCallback = () => void;
type Eip1193Provider = {
  request: (args: {
    method: string;
    params: any[];
  }) => Promise<any>;
  on: (event: string, listener: (...args: any[]) => void) => void;
  removeListener: (event: string, listener: (...args: any[]) => void) => void;
};
type CosmosWalletAbstraction = {
  enableGasCheck?(chainId: ChainId): Promise<void> | void;
  disableGasCheck?(chainId: ChainId): Promise<void> | void;
  signEIP712CosmosTx(args: {
    signDoc: StdSignDoc;
    eip712: any;
  }): Promise<AminoSignResponse>;
};
type MagicMetadata = {
  apiKey?: string;
  rpcEndpoint?: string;
};
type PrivateKeyMetadata = {
  privateKey: string;
};
type WalletConnectMetadata = {
  projectId?: string;
};
interface WalletStrategyEvmOptions {
  evmChainId: EvmChainId;
  rpcUrl?: string;
  rpcUrls?: Partial<Record<number, string>>;
}
interface SendTransactionOptions {
  address: string;
  chainId: ChainId;
  txTimeout?: number;
  txInclusion?: TxClientInclusionOptions;
  onBroadcast?: (txHash: string) => void;
  endpoints: {
    rest: string;
    grpc: string;
    tm?: string;
  };
}
declare const TurnkeyProvider: {
  readonly Sms: "sms";
  readonly Apple: "apple";
  readonly Email: "email";
  readonly Google: "google";
  readonly Twitter: "twitter";
};
type TurnkeyProvider = (typeof TurnkeyProvider)[keyof typeof TurnkeyProvider];
type TurnkeyOAuthProvider = typeof TurnkeyProvider.Apple | typeof TurnkeyProvider.Google | typeof TurnkeyProvider.Twitter;
type TurnkeySession = {
  sessionType: any;
  userId: string;
  organizationId: string;
  expiry: number;
  token: string;
};
interface TurnkeyMetadata {
  apiBaseUrl: string;
  otpInitPath?: string;
  otpVerifyPath?: string;
  googleClientId?: string;
  oauthLoginPath?: string;
  session?: TurnkeySession;
  twitterClientId?: string;
  apiServerEndpoint: string;
  credentialBundle?: string;
  googleRedirectUri?: string;
  expirationSeconds?: string;
  twitterRedirectUri?: string;
  oauth2ExchangePath?: string;
  defaultOrganizationId: string;
}
interface WalletMetadata {
  magic?: MagicMetadata;
  turnkey?: Partial<TurnkeyMetadata>;
  walletConnect?: WalletConnectMetadata;
  privateKey?: PrivateKeyMetadata;
  derivationPath?: string;
  baseDerivationPath?: string;
}
interface ConcreteWalletStrategyArgs {
  chainId: ChainId;
  metadata?: WalletMetadata;
  emitter?: StrategyEmitter;
}
interface ConcreteEvmWalletStrategyArgs extends ConcreteWalletStrategyArgs {
  evmOptions: WalletStrategyEvmOptions;
}
interface ConcreteCosmosWalletStrategyArgs extends ConcreteWalletStrategyArgs {
  wallet?: Wallet;
}
interface ConcreteCosmosWalletStrategy {
  metadata?: WalletMetadata;
  setMetadata?(metadata?: WalletMetadata): void;
  /**
   * The accounts from the wallet (addresses)
   */
  getAddresses(args?: unknown): Promise<string[]>;
  /**
   * The accounts from the wallet with derivation path info (for hardware wallets)
   */
  getAddressesInfo(args?: unknown): Promise<{
    address: string;
    derivationPath: string;
    baseDerivationPath: string;
  }[]>;
  /**
   * Return the WalletDeviceType connected on the
   * wallet provider (extension, mobile, hardware wallet)
   */
  getWalletDeviceType(): Promise<WalletDeviceType>;
  /**
   * Get the PubKey from the wallet
   * in base64 for Cosmos native wallets
   */
  getPubKey(address?: string): Promise<string>;
  /**
   * Perform validations and checks
   * for the wallet (if the chain is supported, etc)
   */
  enable(args?: unknown): Promise<boolean>;
  /**
   * Sends Cosmos transaction. Returns a transaction hash
   * @param transaction should implement TransactionConfig
   * @param options
   */
  sendTransaction(transaction: DirectSignResponse | TxRaw, options: SendTransactionOptions): Promise<TxResponse>;
  signCosmosTransaction(transaction: {
    txRaw: TxRaw;
    chainId: string;
    accountNumber: number;
    address: string;
  }): Promise<DirectSignResponse>;
  signAminoTransaction(transaction: {
    stdSignDoc: StdSignDoc;
    address: string;
  }): Promise<AminoSignResponse>;
}
type ConcreteStrategiesArg = { [key in Wallet]?: ConcreteWalletStrategy };
interface WalletStrategyArguments {
  chainId: ChainId;
  metadata?: WalletMetadata;
  evmOptions?: WalletStrategyEvmOptions;
  disabledWallets?: Wallet[];
  wallet?: Wallet;
  strategies: ConcreteStrategiesArg;
}
interface ConcreteWalletStrategy extends Omit<ConcreteCosmosWalletStrategy, 'sendTransaction' | 'isChainIdSupported' | 'signAminoTransaction'> {
  /**
   * The accounts from the wallet with derivation path info (for hardware wallets)
   */
  getAddressesInfo(args?: unknown): Promise<{
    address: string;
    derivationPath: string;
    baseDerivationPath: string;
  }[]>;
  /**
   * Sends Cosmos transaction. Returns a transaction hash
   * @param transaction should implement TransactionConfig
   * @param options
   */
  sendTransaction(transaction: DirectSignResponse | TxRaw, options: {
    address: string;
    chainId: ChainId;
    txTimeout?: number;
    txInclusion?: TxClientInclusionOptions;
    onBroadcast?: (txHash: string) => void;
    endpoints?: {
      rest: string;
      grpc: string;
      tm?: string;
    };
  }): Promise<TxResponse>;
  /**
   * Confirm the address on the wallet
   * @param address address
   */
  getSessionOrConfirm(address?: string): Promise<string>;
  /**
   * Sends Ethereum transaction. Returns a transaction hash
   * @param transaction should implement TransactionConfig
   * @param options
   */
  sendEvmTransaction(transaction: unknown, options: {
    address: string;
    evmChainId: EvmChainId;
  }): Promise<string>;
  /**
   * Sign a cosmos transaction using the wallet provider
   *
   * @param transaction
   * @param address - injective address
   */
  signCosmosTransaction(transaction: {
    txRaw: TxRaw;
    accountNumber: number;
    chainId: string;
    address: string;
  }): Promise<DirectSignResponse>;
  /**
   * Sign an amino sign doc using the wallet provider
   *
   * @param transaction
   * @param address - injective address
   */
  signAminoCosmosTransaction(transaction: {
    signDoc: StdSignDoc;
    address: string;
  }): Promise<AminoSignResponse>;
  /**
   * Sign EIP712 TypedData using the wallet provider
   * @param eip712TypedData
   * @param address - ethereum address
   */
  signEip712TypedData(eip712TypedData: string, address: string, options?: {
    txTimeout?: number;
  }): Promise<string>;
  signArbitrary(signer: string, data: string | Uint8Array): Promise<string>;
  getEthereumChainId(): Promise<string>;
  getEvmTransactionReceipt(txHash: string, evmChainId?: EvmChainId): void;
  onAccountChange?(callback: onAccountChangeCallback): Promise<void> | void;
  onChainIdChange?(callback: onChainIdChangeCallback): Promise<void> | void;
  initStrategy?(): Promise<void> | void;
  disconnect?(): Promise<void> | void;
  getCosmosWallet?(chainId: ChainId): CosmosWalletAbstraction;
  getWalletClient?<T>(): Promise<T>;
  getEip1193Provider?(): Promise<Eip1193Provider>;
  getOfflineSigner?(chainId: string): Promise<OfflineSigner>;
}
interface WalletStrategy {
  strategies: ConcreteStrategiesArg;
  wallet: Wallet;
  args: WalletStrategyArguments;
  metadata?: WalletMetadata;
  getWallet(): Wallet;
  getWalletClient?<T>(): Promise<T>;
  setWallet(wallet: Wallet): Promise<void>;
  setMetadata(metadata?: WalletMetadata): void;
  getStrategy(): ConcreteWalletStrategy;
  getAddresses(args?: unknown): Promise<AccountAddress[]>;
  getAddressesInfo(args?: unknown): Promise<{
    address: string;
    derivationPath: string;
    baseDerivationPath: string;
  }[]>;
  getWalletDeviceType(): Promise<WalletDeviceType>;
  getPubKey(address?: string): Promise<string>;
  enable(args?: unknown): Promise<boolean>;
  enableAndGetAddresses(args?: unknown): Promise<AccountAddress[]>;
  getEthereumChainId(): Promise<string>;
  getEvmTransactionReceipt(txHash: string, evmChainId?: EvmChainId): Promise<void>;
  getSessionOrConfirm(address?: AccountAddress): Promise<string>;
  sendTransaction(tx: DirectSignResponse | TxRaw, options: SendTransactionOptions): Promise<TxResponse>;
  sendEvmTransaction(tx: any, options: {
    address: AccountAddress;
    evmChainId: EvmChainId;
  }): Promise<string>;
  signEip712TypedData(eip712TypedData: string, address: AccountAddress, options?: {
    txTimeout?: number;
  }): Promise<string>;
  signAminoCosmosTransaction(transaction: {
    signDoc: StdSignDoc;
    address: string;
  }): Promise<AminoSignResponse>;
  signCosmosTransaction(transaction: {
    txRaw: TxRaw;
    accountNumber: number;
    chainId: string;
    address: string;
  }): Promise<DirectSignResponse>;
  signArbitrary(signer: string, data: string | Uint8Array): Promise<string | void>;
  onAccountChange(callback: onAccountChangeCallback): Promise<void>;
  onChainIdChange(callback: onChainIdChangeCallback): Promise<void>;
  disconnect(): Promise<void>;
  getCosmosWallet?(chainId: ChainId): CosmosWalletAbstraction;
  getEip1193Provider?(): Promise<Eip1193Provider>;
  getOfflineSigner?(chainId: string): Promise<OfflineSigner>;
  deleteCurrentSubOrganization?(): Promise<{
    organizationId: string;
  }>;
}
//#endregion
export { WalletDeviceType as A, onAccountChangeCallback as C, MagicProvider as D, EvmWalletProviderErrorCode as E, WalletStrategyEmitterEventType as F, WalletStrategyEmitterEvents as I, StrategyEventType as M, WalletConnectStrategyEventType as N, Wallet as O, WalletStrategyEmitter as P, WalletStrategyEvmOptions as S, BroadcastMode as T, TurnkeySession as _, ConcreteWalletStrategy as a, WalletStrategy as b, Eip1193Provider as c, SendTransactionOptions as d, StdSignDoc as f, TurnkeyProvider as g, TurnkeyOAuthProvider as h, ConcreteStrategiesArg as i, WalletEventListener as j, WalletAction as k, MagicMetadata as l, TurnkeyMetadata as m, ConcreteCosmosWalletStrategyArgs as n, ConcreteWalletStrategyArgs as o, StrategyEmitter as p, ConcreteEvmWalletStrategyArgs as r, CosmosWalletAbstraction as s, ConcreteCosmosWalletStrategy as t, PrivateKeyMetadata as u, WalletConnectMetadata as v, onChainIdChangeCallback as w, WalletStrategyArguments as x, WalletMetadata as y };