export declare const RetryPresets: {
  readonly none: {
    readonly maxRetries: 0
    readonly retryDelayMs: 0
    readonly backoffMultiplier: 1
    readonly maxRetryDelayMs: 0
  }
  readonly fast: {
    readonly maxRetries: 3
    readonly retryDelayMs: 500
    readonly backoffMultiplier: 1.5
    readonly maxRetryDelayMs: 5000
  }
  readonly standard: {
    readonly maxRetries: 3
    readonly retryDelayMs: 1000
    readonly backoffMultiplier: 2
    readonly maxRetryDelayMs: 10000
  }
  readonly aggressive: {
    readonly maxRetries: 5
    readonly retryDelayMs: 1000
    readonly backoffMultiplier: 2
    readonly maxRetryDelayMs: 30000
  }
}

export declare class ProviderError

export type ApiWalletClient = EffectToPromiseAPI<ApiWalletEffect> & {
  readonly attachProvider: (config: ProviderConfig) => SigningClient
  readonly Effect: ApiWalletEffect
}

export interface ApiWalletConfig {
  readonly type: "api"
  readonly api: WalletApi
}

export interface BlockfrostConfig {
  readonly type: "blockfrost"
  readonly baseUrl: string
  readonly projectId?: string
  readonly retryPolicy?: RetryPolicy
}

export interface KoiosConfig {
  readonly type: "koios"
  readonly baseUrl: string
  readonly token?: string
  readonly retryPolicy?: RetryPolicy
}

export interface KupmiosConfig {
  readonly type: "kupmios"
  readonly kupoUrl: string
  readonly ogmiosUrl: string
  readonly headers?: {
    readonly ogmiosHeader?: Record<string, string>
    readonly kupoHeader?: Record<string, string>
  }
  readonly retryPolicy?: RetryPolicy
}

export interface MaestroConfig {
  readonly type: "maestro"
  readonly baseUrl: string
  readonly apiKey: string
  readonly turboSubmit?: boolean
  readonly retryPolicy?: RetryPolicy
}

export interface MinimalClient {
  readonly networkId: number | string
  readonly attachProvider: (config: ProviderConfig) => ProviderOnlyClient
  readonly attachWallet: <T extends WalletConfig>(
    config: T
  ) => T extends SeedWalletConfig
    ? SigningWalletClient
    : T extends PrivateKeyWalletConfig
      ? SigningWalletClient
      : T extends ApiWalletConfig
        ? ApiWalletClient
        : ReadOnlyWalletClient
  readonly attach: <TW extends WalletConfig>(
    providerConfig: ProviderConfig,
    walletConfig: TW
  ) => TW extends SeedWalletConfig
    ? SigningClient
    : TW extends PrivateKeyWalletConfig
      ? SigningClient
      : TW extends ApiWalletConfig
        ? SigningClient
        : ReadOnlyClient
  readonly Effect: MinimalClientEffect
}

export interface MinimalClientEffect {
  readonly networkId: Effect.Effect<number | string, never>
}

export type NetworkId = "mainnet" | "preprod" | "preview" | number

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

export type ProviderConfig = BlockfrostConfig | KupmiosConfig | MaestroConfig | KoiosConfig

export type ProviderOnlyClient = EffectToPromiseAPI<Provider.ProviderEffect> & {
  readonly attachWallet: <T extends WalletConfig>(
    config: T
  ) => T extends SeedWalletConfig
    ? SigningClient
    : T extends PrivateKeyWalletConfig
      ? SigningClient
      : T extends ApiWalletConfig
        ? SigningClient
        : ReadOnlyClient
  readonly Effect: Provider.ProviderEffect
}

export type ReadOnlyClient = EffectToPromiseAPI<ReadOnlyClientEffect> & {
  readonly newTx: (utxos?: ReadonlyArray<CoreUTxO.UTxO>) => ReadOnlyTransactionBuilder
  readonly Effect: ReadOnlyClientEffect
}

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

export type ReadOnlyWalletClient = EffectToPromiseAPI<ReadOnlyWalletEffect> & {
  readonly networkId: number | string
  readonly attachProvider: (config: ProviderConfig) => ReadOnlyClient
  readonly Effect: ReadOnlyWalletEffect
}

export interface ReadOnlyWalletConfig {
  readonly type: "read-only"
  readonly address: string
  readonly rewardAddress?: string
}

export interface RetryConfig {
  readonly maxRetries: number
  readonly retryDelayMs: number
  readonly backoffMultiplier: number
  readonly maxRetryDelayMs: number
}

export type RetryPolicy = RetryConfig | Schedule.Schedule<any, any> | { preset: keyof typeof RetryPresets }

export interface SeedWalletConfig {
  readonly type: "seed"
  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 newTx: () => SigningTransactionBuilder
  readonly Effect: SigningClientEffect
}

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

export type SigningWalletClient = EffectToPromiseAPI<SigningWalletEffect> & {
  readonly networkId: number | string
  readonly attachProvider: (config: ProviderConfig) => SigningClient
  readonly Effect: SigningWalletEffect
}

export type WalletConfig = SeedWalletConfig | PrivateKeyWalletConfig | ReadOnlyWalletConfig | ApiWalletConfig