export declare const make: (chain?: Chain) => ClientAssembly

export type AddressClient = EffectToPromiseAPI<AddressClientEffect> & {
  readonly chain: Chain
  readonly withBlockfrost: (config: BlockfrostConfig) => ReadOnlyClient
  readonly withKoios: (config: KoiosConfig) => ReadOnlyClient
  readonly withKupmios: (config: KupmiosConfig) => ReadOnlyClient
  readonly withMaestro: (config: MaestroConfig) => ReadOnlyClient
  readonly effect: AddressClientEffect
}

export interface AddressClientEffect extends Wallet.ReadOnlyWalletEffect {}

export interface BlockfrostConfig {
  readonly baseUrl: string
  readonly projectId?: string
}

export interface ClientAssembly {
  readonly chain: Chain
  readonly withBlockfrost: (config: BlockfrostConfig) => ReadClient
  readonly withKoios: (config: KoiosConfig) => ReadClient
  readonly withKupmios: (config: KupmiosConfig) => ReadClient
  readonly withMaestro: (config: MaestroConfig) => ReadClient
  readonly withAddress: (address: string, rewardAddress?: string) => AddressClient
  readonly withSeed: (config: SeedWalletConfig) => OfflineSignerClient
  readonly withPrivateKey: (config: PrivateKeyWalletConfig) => OfflineSignerClient
  readonly withCip30: (api: Wallet.WalletApi) => OfflineSignerClient
}

export interface KoiosConfig {
  readonly baseUrl: string
  readonly token?: string
}

export interface KupmiosConfig {
  readonly kupoUrl: string
  readonly ogmiosUrl: string
  readonly headers?: {
    readonly ogmiosHeader?: Record<string, string>
    readonly kupoHeader?: Record<string, string>
  }
}

export interface MaestroConfig {
  readonly baseUrl: string
  readonly apiKey: string
  readonly turboSubmit?: boolean
}

export type OfflineSignerClient = EffectToPromiseAPI<OfflineSignerClientEffect> & {
  readonly chain: Chain
  readonly withBlockfrost: (config: BlockfrostConfig) => SigningClient
  readonly withKoios: (config: KoiosConfig) => SigningClient
  readonly withKupmios: (config: KupmiosConfig) => SigningClient
  readonly withMaestro: (config: MaestroConfig) => SigningClient
  readonly effect: OfflineSignerClientEffect
}

export interface OfflineSignerClientEffect extends AddressClientEffect {
  readonly signTx: (
    tx: Parameters<Wallet.SigningWalletEffect["signTx"]>[0],
    context?: Parameters<Wallet.SigningWalletEffect["signTx"]>[1]
  ) => ReturnType<Wallet.SigningWalletEffect["signTx"]>
  /**
   * Sign multiple transactions in batch (CIP-103).
   * Falls back to sequential signTx if the wallet doesn't support batch signing.
   *
   * @since 2.2.0
   */
  readonly signTxs: (
    txs: Parameters<Wallet.SigningWalletEffect["signTxs"]>[0],
    context?: Parameters<Wallet.SigningWalletEffect["signTxs"]>[1]
  ) => ReturnType<Wallet.SigningWalletEffect["signTxs"]>
  readonly signMessage: Wallet.SigningWalletEffect["signMessage"]
}

export interface PrivateKeyWalletConfig {
  readonly paymentKey: string
  readonly stakeKey?: string
  readonly addressType?: "Base" | "Enterprise"
}

export type ReadClient = EffectToPromiseAPI<Provider.ProviderEffect> & {
  readonly chain: Chain
  readonly withAddress: (address: string, rewardAddress?: string) => ReadOnlyClient
  readonly withSeed: (config: SeedWalletConfig) => SigningClient
  readonly withPrivateKey: (config: PrivateKeyWalletConfig) => SigningClient
  readonly withCip30: (api: Wallet.WalletApi) => SigningClient
  readonly newTx: () => ReadOnlyTransactionBuilder
  readonly effect: Provider.ProviderEffect
}

export type ReadOnlyClient = EffectToPromiseAPI<ReadOnlyClientEffect> & {
  readonly chain: Chain
  readonly newTx: () => ReadOnlyTransactionBuilder
  readonly effect: ReadOnlyClientEffect
}

export interface ReadOnlyClientEffect extends Provider.ProviderEffect, AddressClientEffect {
  readonly getWalletUtxos: () => Effect.Effect<
    ReadonlyArray<CoreUTxO.UTxO>,
    Wallet.WalletError | Provider.ProviderError
  >
  readonly getWalletDelegation: () => Effect.Effect<Provider.Delegation, Wallet.WalletError | Provider.ProviderError>
}

export interface SeedWalletConfig {
  readonly mnemonic: string
  readonly accountIndex?: number
  readonly paymentIndex?: number
  readonly stakeIndex?: number
  readonly addressType?: "Base" | "Enterprise"
  readonly password?: string
}

export type SigningClient = EffectToPromiseAPI<SigningClientEffect> & {
  readonly chain: Chain
  readonly newTx: () => SigningTransactionBuilder
  readonly effect: SigningClientEffect
}

export interface SigningClientEffect extends Provider.ProviderEffect, OfflineSignerClientEffect {
  readonly getWalletUtxos: () => Effect.Effect<
    ReadonlyArray<CoreUTxO.UTxO>,
    Wallet.WalletError | Provider.ProviderError
  >
  readonly getWalletDelegation: () => Effect.Effect<Provider.Delegation, Wallet.WalletError | Provider.ProviderError>
}