from notareum import Notareum

Notareum(
    provider,                  # web3.Web3 instance
    contracts: dict[str, str], # see ContractAddresses
    account=None,              # optional eth_account.Account
) -> Notareum

class NotaFileClient:
    def create(
        self,
        *,
        type: str,
        chain_name: str,
        chain_id: int,
        identifier: str,
        network: str | None = None,
        name: str | None = None,
        alias: str | None = None,
        description: str | None = None,
        resource_metadata: dict | None = None,
        issuer_name: str | None = None,
        issuer_entity_type: str | None = None,
    ) -> NotaBuilder

    def parse(self, content: str) -> dict
    def validate(self, nota: dict) -> None
    def is_valid(self, nota: dict) -> bool
    def serialize(self, nota: dict) -> str

class NotaBuilder:
    def sign(self, private_key: str) -> NotaBuilder
    def validate(self) -> NotaBuilder
    def serialize(self) -> str
    def build(self) -> dict

class RegistryClient:
    def register_resource(
        self, *,
        resource_type: int,
        chain_id: int,
        identifier: str,
        proof_hash: str | bytes,
        alias: str = "",
    ) -> str

    def get_resource(self, resource_id: bytes | str) -> ResourceInfo
    def resolve_alias(self, alias: str) -> str
    def revoke_resource(self, resource_id: bytes | str) -> str

    def compute_resource_id(
        self, *,
        resource_type: int,
        chain_id: int,
        identifier: str,
    ) -> str

    def add_resource_type(self, type_id: int, name: str) -> str
    def remove_resource_type(self, type_id: int) -> str
    def is_valid_resource_type(self, type_id: int) -> bool
    def get_resource_type_name(self, type_id: int) -> str

class VerificationClient:
    def request_verification(
        self,
        resource_id: bytes | str,
        level: VerificationLevel | int,
    ) -> str

    def submit_attestation(
        self,
        resource_id: bytes | str,
        approved: bool,
    ) -> str

    def get_verification_request(self, request_id: int) -> VerificationRequest
    def get_verification_fee(self, level: VerificationLevel | int) -> int

class StakingClient:
    def stake(self, amount: int) -> str
    def unstake(self) -> str
    def claim_stake(self) -> str

    def get_validator_info(self, address: str) -> ValidatorInfo
    def get_tier(self, address: str) -> ValidatorTier
    def get_daily_verifications_remaining(self, address: str) -> int
    def get_tier_threshold(self, tier: ValidatorTier | int) -> int

class GovernanceClient:
    def lock(self, amount: int, duration: int) -> str
    def extend_lock(self, lock_id: int, additional_duration: int) -> str
    def unlock(self, lock_id: int) -> str

    def get_voting_power(self, address: str) -> int
    def get_lock(self, lock_id: int) -> VeNOTALock
    def get_total_supply(self) -> int

class FeeClient:
    def get_verification_fee(self, level: int) -> int
    def get_alias_fee(self) -> int
    def get_dispute_bond(self) -> int
    def get_fee_collector(self) -> str
    def get_fee_config(self) -> FeeConfig

    # Governance only
    def set_verification_fee(self, level: int, fee: int) -> str
    def set_alias_fee(self, fee: int) -> str

from enum import IntEnum

class VerificationLevel(IntEnum):
    BASIC = 0
    ENHANCED = 1
    INSTITUTIONAL = 2

class VerificationStatus(IntEnum):
    PENDING = 0
    APPROVED = 1
    REJECTED = 2
    EXPIRED = 3

class ValidatorTier(IntEnum):
    NONE = 0
    BRONZE = 1       # protocol: BASIC
    SILVER = 2       # protocol: PROFESSIONAL
    GOLD = 3         # protocol: ENTERPRISE
    PLATINUM = 4     # protocol: INSTITUTIONAL

from notareum.core.errors import (
    ConfigurationError,
    SignerRequiredError,
    ContractCallError,
    ResourceNotFoundError,
)