function Notareum(config: ClientConfig): NotareumInstance

interface ClientConfig {
  provider: Provider;
  signer?: Signer;
  contracts: ContractAddresses;
}

interface NotareumInstance {
  nota: NotaFileClient;
  registry: RegistryClient;
  verification: VerificationClient;
  staking: StakingClient;
  governance: GovernanceClient;
  fee: FeeClient;
}

class NotaFileClient {
  create(options: CreateNotaOptions): NotaBuilder;
  parse(content: string): NotaFile;
  validate(nota: NotaFile): void;
  isValid(nota: NotaFile): boolean;
  serialize(nota: NotaFile): string;
}

class NotaBuilder {
  sign(signer: Signer): Promise<NotaBuilder>;
  validate(): NotaBuilder;
  serialize(): string;
  build(): NotaFile;
}

class RegistryClient {
  registerResource(
    resourceType: number,
    chainId: bigint | number,
    identifier: string,
    proofHash: string,
    alias?: string
  ): Promise<string>;

  getResource(resourceId: string): Promise<ResourceInfo>;
  resolveAlias(alias: string): Promise<string>;
  revokeResource(resourceId: string): Promise<string>;

  computeResourceId(
    resourceType: number,
    chainId: bigint | number,
    identifier: string
  ): string;

  addResourceType(typeId: number, name: string): Promise<string>;
  removeResourceType(typeId: number): Promise<string>;
  isValidResourceType(typeId: number): Promise<boolean>;
  getResourceTypeName(typeId: number): Promise<string>;
}

class VerificationClient {
  requestVerification(
    resourceId: string,
    level: VerificationLevel
  ): Promise<string>;

  submitAttestation(
    resourceId: string,
    approved: boolean
  ): Promise<string>;

  getVerificationRequest(
    requestId: bigint | number
  ): Promise<VerificationRequest>;

  getVerificationFee(level: VerificationLevel): Promise<bigint>;
}

class StakingClient {
  stake(amount: bigint): Promise<string>;
  unstake(): Promise<string>;
  claimStake(): Promise<string>;

  getValidatorInfo(address: string): Promise<ValidatorInfo>;
  getTier(address: string): Promise<ValidatorTier>;
  getDailyVerificationsRemaining(address: string): Promise<bigint>;
  getTierThreshold(tier: ValidatorTier): Promise<bigint>;
}

class GovernanceClient {
  lock(amount: bigint, duration: bigint): Promise<string>;
  extendLock(lockId: bigint, additionalDuration: bigint): Promise<string>;
  unlock(lockId: bigint): Promise<string>;

  getVotingPower(address: string): Promise<bigint>;
  getLock(lockId: bigint): Promise<VeNOTALock>;
  getTotalSupply(): Promise<bigint>;
}

class FeeClient {
  getVerificationFee(level: number): Promise<bigint>;
  getAliasFee(): Promise<bigint>;
  getDisputeBond(): Promise<bigint>;
  getFeeCollector(): Promise<string>;
  getFeeConfig(): Promise<FeeConfig>;

  // Governance only
  setVerificationFee(level: number, fee: bigint): Promise<string>;
  setAliasFee(fee: bigint): Promise<string>;
}

const ResourceType = {
  ADDRESS: 0,
  TRANSACTION: 1,
  CONTRACT: 2,
  IPFS: 3,
  NFT: 4,
  METADATA: 5,
} as const;

enum VerificationLevel { BASIC = 0, ENHANCED = 1, INSTITUTIONAL = 2 }
enum VerificationStatus { PENDING = 0, APPROVED = 1, REJECTED = 2, EXPIRED = 3 }
enum ValidatorTier { NONE = 0, BRONZE = 1, SILVER = 2, GOLD = 3, PLATINUM = 4 }

import {
  computeResourceId,
  registerResourceType,
  resolveResourceTypeId,
  resolveResourceTypeString,
  isValidResourceType,
} from "@notareum/sdk";