@polymeshassociation/polymesh-sdk 24.2.0-alpha.1 → 24.2.1

package/types/index.d.ts

@@ -1,1420 +1,12 @@
-import { ApiOptions } from '@polkadot/api/types';
-import { TypeDef } from '@polkadot/types/types';
-import BigNumber from 'bignumber.js';
-import { CorporateActionTargets, DividendDistributionDetails, OfferingDetails, ScheduleDetails, SubsidyData, TaxWithholding } from "../api/entities/types";
-import { CreateTransactionBatchParams } from "../api/procedures/types";
 import { CountryCode, ModuleName, TxTag, TxTags } from "../generated/types";
-import { Account, BaseAsset, Checkpoint, CheckpointSchedule, CustomPermissionGroup, DefaultPortfolio, DefaultTrustedClaimIssuer, DividendDistribution, FungibleAsset, Identity, Instruction, KnownPermissionGroup, Nft, NftCollection, NumberedPortfolio, Offering, PolymeshTransaction, PolymeshTransactionBatch } from "../internal";
-import { Modify } from "./utils";
 export { EventRecord } from '@polkadot/types/interfaces';
 export { ConnectParams } from "../api/client/Polymesh";
+export * from "../api/client/types";
 export * from "../api/entities/types";
 export * from "../api/procedures/types";
 export * from "../base/types";
 export * from "../generated/types";
-export { AssetHoldersOrderBy, AuthTypeEnum, AuthorizationStatusEnum, ExtrinsicsOrderBy, NftHoldersOrderBy, InstructionStatusEnum, MultiSigProposalVoteActionEnum, SettlementResultEnum, BalanceTypeEnum, ModuleIdEnum, EventIdEnum, CallIdEnum, Scalars, } from "../middleware/types";
+export { AssetHoldersOrderBy, AuthTypeEnum, AuthorizationStatusEnum, BalanceTypeEnum, CallIdEnum, EventIdEnum, ExtrinsicsOrderBy, InstructionStatusEnum, ModuleIdEnum, MultiSigProposalVoteActionEnum, NftHoldersOrderBy, Scalars, SettlementResultEnum, } from "../middleware/types";
 export { ClaimScopeTypeEnum, MiddlewareScope, SettlementDirectionEnum } from "../middleware/typesV1";
 export { CountryCode, ModuleName, TxTag, TxTags };
-export declare enum TransactionStatus {
-    /**
-     * the transaction is prepped to run
-     */
-    Idle = "Idle",
-    /**
-     * the transaction is waiting for the user's signature
-     */
-    Unapproved = "Unapproved",
-    /**
-     * the transaction is being executed
-     */
-    Running = "Running",
-    /**
-     * the transaction was rejected by the signer
-     */
-    Rejected = "Rejected",
-    /**
-     * the transaction was run successfully
-     */
-    Succeeded = "Succeeded",
-    /**
-     * the transaction's execution failed due to a an on-chain validation error, insufficient balance for fees, or other such reasons
-     */
-    Failed = "Failed",
-    /**
-     * the transaction couldn't be broadcast. It was either dropped, usurped or invalidated
-     * see https://github.com/paritytech/substrate/blob/master/primitives/transaction-pool/src/pool.rs#L58-L110
-     */
-    Aborted = "Aborted"
-}
-export declare enum RoleType {
-    TickerOwner = "TickerOwner",
-    CddProvider = "CddProvider",
-    VenueOwner = "VenueOwner",
-    PortfolioCustodian = "PortfolioCustodian",
-    CorporateActionsAgent = "CorporateActionsAgent",
-    Identity = "Identity"
-}
-export interface TickerOwnerRole {
-    type: RoleType.TickerOwner;
-    ticker: string;
-}
-export interface CddProviderRole {
-    type: RoleType.CddProvider;
-}
-export interface VenueOwnerRole {
-    type: RoleType.VenueOwner;
-    venueId: BigNumber;
-}
-export interface PortfolioId {
-    did: string;
-    number?: BigNumber;
-}
-export interface PortfolioCustodianRole {
-    type: RoleType.PortfolioCustodian;
-    portfolioId: PortfolioId;
-}
-export interface IdentityRole {
-    type: RoleType.Identity;
-    did: string;
-}
-export declare type Role = TickerOwnerRole | CddProviderRole | VenueOwnerRole | PortfolioCustodianRole | IdentityRole;
-export declare enum KnownAssetType {
-    EquityCommon = "EquityCommon",
-    EquityPreferred = "EquityPreferred",
-    Commodity = "Commodity",
-    FixedIncome = "FixedIncome",
-    Reit = "Reit",
-    Fund = "Fund",
-    RevenueShareAgreement = "RevenueShareAgreement",
-    StructuredProduct = "StructuredProduct",
-    Derivative = "Derivative",
-    StableCoin = "StableCoin"
-}
-export declare enum KnownNftType {
-    Derivative = "Derivative",
-    FixedIncome = "FixedIncome",
-    Invoice = "Invoice"
-}
-export declare enum SecurityIdentifierType {
-    Isin = "Isin",
-    Cusip = "Cusip",
-    Cins = "Cins",
-    Lei = "Lei",
-    Figi = "Figi"
-}
-/**
- * Alphanumeric standardized security identifier
- */
-export interface SecurityIdentifier {
-    type: SecurityIdentifierType;
-    value: string;
-}
-/**
- * Document attached to a token
- */
-export interface AssetDocument {
-    name: string;
-    uri: string;
-    /**
-     * hex representation of the document (must be prefixed by "0x")
-     */
-    contentHash?: string;
-    type?: string;
-    filedAt?: Date;
-}
-/**
- * Type of Authorization Request
- */
-export declare enum AuthorizationType {
-    AttestPrimaryKeyRotation = "AttestPrimaryKeyRotation",
-    RotatePrimaryKey = "RotatePrimaryKey",
-    TransferTicker = "TransferTicker",
-    AddMultiSigSigner = "AddMultiSigSigner",
-    TransferAssetOwnership = "TransferAssetOwnership",
-    JoinIdentity = "JoinIdentity",
-    PortfolioCustody = "PortfolioCustody",
-    BecomeAgent = "BecomeAgent",
-    AddRelayerPayingKey = "AddRelayerPayingKey",
-    RotatePrimaryKeyToSecondary = "RotatePrimaryKeyToSecondary"
-}
-export declare enum ConditionTarget {
-    Sender = "Sender",
-    Receiver = "Receiver",
-    Both = "Both"
-}
-export declare enum ScopeType {
-    Identity = "Identity",
-    Ticker = "Ticker",
-    Custom = "Custom"
-}
-export interface Scope {
-    type: ScopeType;
-    value: string;
-}
-export declare enum ClaimType {
-    Accredited = "Accredited",
-    Affiliate = "Affiliate",
-    BuyLockup = "BuyLockup",
-    SellLockup = "SellLockup",
-    CustomerDueDiligence = "CustomerDueDiligence",
-    KnowYourCustomer = "KnowYourCustomer",
-    Jurisdiction = "Jurisdiction",
-    Exempted = "Exempted",
-    Blocked = "Blocked",
-    Custom = "Custom"
-}
-export interface AccreditedClaim {
-    type: ClaimType.Accredited;
-    scope: Scope;
-}
-export interface AffiliateClaim {
-    type: ClaimType.Affiliate;
-    scope: Scope;
-}
-export interface BuyLockupClaim {
-    type: ClaimType.BuyLockup;
-    scope: Scope;
-}
-export interface SellLockupClaim {
-    type: ClaimType.SellLockup;
-    scope: Scope;
-}
-export interface CddClaim {
-    type: ClaimType.CustomerDueDiligence;
-    id: string;
-}
-export interface KycClaim {
-    type: ClaimType.KnowYourCustomer;
-    scope: Scope;
-}
-export interface JurisdictionClaim {
-    type: ClaimType.Jurisdiction;
-    code: CountryCode;
-    scope: Scope;
-}
-export interface ExemptedClaim {
-    type: ClaimType.Exempted;
-    scope: Scope;
-}
-export interface CustomClaim {
-    type: ClaimType.Custom;
-    scope: Scope;
-    customClaimTypeId: BigNumber;
-}
-export interface BlockedClaim {
-    type: ClaimType.Blocked;
-    scope: Scope;
-}
-export declare type ScopedClaim = JurisdictionClaim | AccreditedClaim | AffiliateClaim | BuyLockupClaim | SellLockupClaim | KycClaim | ExemptedClaim | BlockedClaim | CustomClaim;
-export declare type UnscopedClaim = CddClaim;
-export declare type Claim = ScopedClaim | UnscopedClaim;
-export interface ClaimData<ClaimType = Claim> {
-    target: Identity;
-    issuer: Identity;
-    issuedAt: Date;
-    lastUpdatedAt: Date;
-    expiry: Date | null;
-    claim: ClaimType;
-}
-export declare type StatClaimType = ClaimType.Accredited | ClaimType.Affiliate | ClaimType.Jurisdiction;
-export interface StatJurisdictionClaimInput {
-    type: ClaimType.Jurisdiction;
-    countryCode?: CountryCode;
-}
-export interface StatAccreditedClaimInput {
-    type: ClaimType.Accredited;
-    accredited: boolean;
-}
-export interface StatAffiliateClaimInput {
-    type: ClaimType.Affiliate;
-    affiliate: boolean;
-}
-export declare type InputStatClaim = StatJurisdictionClaimInput | StatAccreditedClaimInput | StatAffiliateClaimInput;
-export declare type InputStatType = {
-    type: StatType.Count | StatType.Balance;
-} | {
-    type: StatType.ScopedCount | StatType.ScopedBalance;
-    claimIssuer: StatClaimIssuer;
-};
-/**
- * Represents the StatType from the `statistics` module.
- *
- * @note the chain doesn't use "Scoped" types, but they are needed here to discriminate the input instead of having an optional input
- */
-export declare enum StatType {
-    Count = "Count",
-    Balance = "Balance",
-    /**
-     * ScopedCount is an SDK only type, on chain it is `Count` with a claimType option present
-     */
-    ScopedCount = "ScopedCount",
-    /**
-     * ScopedPercentage is an SDK only type, on chain it is `Balance` with a claimType option present
-     */
-    ScopedBalance = "ScopedBalance"
-}
-export interface IdentityWithClaims {
-    identity: Identity;
-    claims: ClaimData[];
-}
-export interface ExtrinsicData {
-    blockHash: string;
-    blockNumber: BigNumber;
-    blockDate: Date;
-    extrinsicIdx: BigNumber;
-    /**
-     * public key of the signer. Unsigned transactions have no signer, in which case this value is null (example: an enacted governance proposal)
-     */
-    address: string | null;
-    /**
-     * nonce of the transaction. Null for unsigned transactions where address is null
-     */
-    nonce: BigNumber | null;
-    txTag: TxTag;
-    params: Record<string, unknown>[];
-    success: boolean;
-    specVersionId: BigNumber;
-    extrinsicHash: string;
-}
-export interface ExtrinsicDataWithFees extends ExtrinsicData {
-    fee: Fees;
-}
-export interface ProtocolFees {
-    tag: TxTag;
-    fees: BigNumber;
-}
-export interface ClaimScope {
-    scope: Scope | null;
-    ticker?: string;
-}
-export interface SubmissionDetails {
-    blockHash: string;
-    transactionIndex: BigNumber;
-    transactionHash: string;
-}
-/**
- * @param IsDefault - whether the Identity is a default trusted claim issuer for an asset or just
- *   for a specific compliance condition. Defaults to false
- */
-export interface TrustedClaimIssuer<IsDefault extends boolean = false> {
-    identity: IsDefault extends true ? DefaultTrustedClaimIssuer : Identity;
-    /**
-     * a null value means that the issuer is trusted for all claim types
-     */
-    trustedFor: ClaimType[] | null;
-}
-export declare type InputTrustedClaimIssuer = Modify<TrustedClaimIssuer, {
-    identity: string | Identity;
-}>;
-export declare enum ConditionType {
-    IsPresent = "IsPresent",
-    IsAbsent = "IsAbsent",
-    IsAnyOf = "IsAnyOf",
-    IsNoneOf = "IsNoneOf",
-    IsExternalAgent = "IsExternalAgent",
-    IsIdentity = "IsIdentity"
-}
-export interface ConditionBase {
-    target: ConditionTarget;
-    /**
-     * if undefined, the default trusted claim issuers for the Asset are used
-     */
-    trustedClaimIssuers?: TrustedClaimIssuer[];
-}
-export declare type InputConditionBase = Modify<ConditionBase, {
-    /**
-     * if undefined, the default trusted claim issuers for the Asset are used
-     */
-    trustedClaimIssuers?: InputTrustedClaimIssuer[];
-}>;
-export interface SingleClaimCondition {
-    type: ConditionType.IsPresent | ConditionType.IsAbsent;
-    claim: Claim;
-}
-export interface MultiClaimCondition {
-    type: ConditionType.IsAnyOf | ConditionType.IsNoneOf;
-    claims: Claim[];
-}
-export interface IdentityCondition {
-    type: ConditionType.IsIdentity;
-    identity: Identity;
-}
-export interface ExternalAgentCondition {
-    type: ConditionType.IsExternalAgent;
-}
-export declare type Condition = (SingleClaimCondition | MultiClaimCondition | IdentityCondition | ExternalAgentCondition) & ConditionBase;
-export declare type InputCondition = (SingleClaimCondition | MultiClaimCondition | Modify<IdentityCondition, {
-    identity: string | Identity;
-}> | ExternalAgentCondition) & InputConditionBase;
-export interface Requirement {
-    id: BigNumber;
-    conditions: Condition[];
-}
-export interface ComplianceRequirements {
-    requirements: Requirement[];
-    /**
-     * used for conditions where no trusted claim issuers were specified
-     */
-    defaultTrustedClaimIssuers: TrustedClaimIssuer[];
-}
-export declare type InputRequirement = Modify<Requirement, {
-    conditions: InputCondition[];
-}>;
-export interface ConditionCompliance {
-    condition: Condition;
-    complies: boolean;
-}
-export interface RequirementCompliance {
-    id: BigNumber;
-    conditions: ConditionCompliance[];
-    complies: boolean;
-}
-export interface Compliance {
-    requirements: RequirementCompliance[];
-    complies: boolean;
-}
-/**
- * Specifies possible types of errors in the SDK
- */
-export declare enum ErrorCode {
-    /**
-     * transaction removed from the tx pool
-     */
-    TransactionAborted = "TransactionAborted",
-    /**
-     * user rejected the transaction in their wallet
-     */
-    TransactionRejectedByUser = "TransactionRejectedByUser",
-    /**
-     * transaction failed due to an on-chain error. This is a business logic error,
-     *   and it should be caught by the SDK before being sent to the chain.
-     *   Please report it to the Polymesh team
-     */
-    TransactionReverted = "TransactionReverted",
-    /**
-     * error that should cause termination of the calling application
-     */
-    FatalError = "FatalError",
-    /**
-     * user input error. This means that one or more inputs passed by the user
-     *   do not conform to expected value ranges or types
-     */
-    ValidationError = "ValidationError",
-    /**
-     * user does not have the required roles/permissions to perform an operation
-     */
-    NotAuthorized = "NotAuthorized",
-    /**
-     * errors encountered when interacting with the historic data middleware (GQL server)
-     */
-    MiddlewareError = "MiddlewareError",
-    /**
-     * the data that is being fetched does not exist on-chain, or relies on non-existent data. There are
-     *   some cases where the data did exist at some point, but has been deleted to save storage space
-     */
-    DataUnavailable = "DataUnavailable",
-    /**
-     * the data that is being written to the chain is the same data that is already in place. This would result
-     *   in a redundant/useless transaction being executed
-     */
-    NoDataChange = "NoDataChange",
-    /**
-     * the data that is being written to the chain would result in some limit being exceeded. For example, adding a transfer
-     *   restriction when the maximum possible amount has already been added
-     */
-    LimitExceeded = "LimitExceeded",
-    /**
-     * one or more base prerequisites for a transaction to be successful haven't been met. For example, reserving a ticker requires
-     *   said ticker to not be already reserved. Attempting to reserve a ticker without that prerequisite being met would result in this
-     *   type of error. Attempting to create an entity that already exists would also fall into this category,
-     *   if the entity in question is supposed to be unique
-     */
-    UnmetPrerequisite = "UnmetPrerequisite",
-    /**
-     * this type of error is thrown when attempting to delete/modify an entity which has other entities depending on it. For example, deleting
-     *   a Portfolio that still holds assets, or removing a Checkpoint Schedule that is being referenced by a Corporate Action
-     */
-    EntityInUse = "EntityInUse",
-    /**
-     * one or more parties involved in the transaction do not have enough balance to perform it
-     */
-    InsufficientBalance = "InsufficientBalance",
-    /**
-     * errors that are the result of something unforeseen.
-     *   These should generally be reported to the Polymesh team
-     */
-    UnexpectedError = "UnexpectedError",
-    /**
-     * general purpose errors that don't fit well into the other categories
-     */
-    General = "General"
-}
-/**
- * ERC1400 compliant transfer status
- */
-export declare enum TransferStatus {
-    Failure = "Failure",
-    Success = "Success",
-    InsufficientBalance = "InsufficientBalance",
-    InsufficientAllowance = "InsufficientAllowance",
-    TransfersHalted = "TransfersHalted",
-    FundsLocked = "FundsLocked",
-    InvalidSenderAddress = "InvalidSenderAddress",
-    InvalidReceiverAddress = "InvalidReceiverAddress",
-    InvalidOperator = "InvalidOperator",
-    InvalidSenderIdentity = "InvalidSenderIdentity",
-    InvalidReceiverIdentity = "InvalidReceiverIdentity",
-    ComplianceFailure = "ComplianceFailure",
-    SmartExtensionFailure = "SmartExtensionFailure",
-    InvalidGranularity = "InvalidGranularity",
-    VolumeLimitReached = "VolumeLimitReached",
-    BlockedTransaction = "BlockedTransaction",
-    FundsLimitReached = "FundsLimitReached",
-    PortfolioFailure = "PortfolioFailure",
-    CustodianError = "CustodianError",
-    ScopeClaimMissing = "ScopeClaimMissing",
-    TransferRestrictionFailure = "TransferRestrictionFailure"
-}
-/**
- * Akin to TransferStatus, these are a bit more granular and specific. Every TransferError translates to
- *   a {@link TransferStatus}, but two or more TransferErrors can represent the same TransferStatus, and
- *   not all Transfer Statuses are represented by a TransferError
- */
-export declare enum TransferError {
-    /**
-     * translates to TransferStatus.InvalidGranularity
-     *
-     * occurs if attempting to transfer decimal amounts of a non-divisible token
-     */
-    InvalidGranularity = "InvalidGranularity",
-    /**
-     * translates to TransferStatus.InvalidReceiverIdentity
-     *
-     * occurs if the origin and destination Identities are the same
-     */
-    SelfTransfer = "SelfTransfer",
-    /**
-     * translates to TransferStatus.InvalidReceiverIdentity
-     *
-     * occurs if the receiver Identity doesn't have a valid CDD claim
-     */
-    InvalidReceiverCdd = "InvalidReceiverCdd",
-    /**
-     * translates to TransferStatus.InvalidSenderIdentity
-     *
-     * occurs if the receiver Identity doesn't have a valid CDD claim
-     */
-    InvalidSenderCdd = "InvalidSenderCdd",
-    /**
-     * translates to TransferStatus.ScopeClaimMissing
-     *
-     * occurs if one of the participants doesn't have a valid Investor Uniqueness Claim for
-     *   the Asset
-     */
-    ScopeClaimMissing = "ScopeClaimMissing",
-    /**
-     * translates to TransferStatus.InsufficientBalance
-     *
-     * occurs if the sender Identity does not have enough balance to cover the amount
-     */
-    InsufficientBalance = "InsufficientBalance",
-    /**
-     * translates to TransferStatus.TransfersHalted
-     *
-     * occurs if the Asset's transfers are frozen
-     */
-    TransfersFrozen = "TransfersFrozen",
-    /**
-     * translates to TransferStatus.PortfolioFailure
-     *
-     * occurs if the sender Portfolio doesn't exist
-     */
-    InvalidSenderPortfolio = "InvalidSenderPortfolio",
-    /**
-     * translates to TransferStatus.PortfolioFailure
-     *
-     * occurs if the receiver Portfolio doesn't exist
-     */
-    InvalidReceiverPortfolio = "InvalidReceiverPortfolio",
-    /**
-     * translates to TransferStatus.PortfolioFailure
-     *
-     * occurs if the sender Portfolio does not have enough balance to cover the amount
-     */
-    InsufficientPortfolioBalance = "InsufficientPortfolioBalance",
-    /**
-     * translates to TransferStatus.ComplianceFailure
-     *
-     * occurs if some compliance rule would prevent the transfer
-     */
-    ComplianceFailure = "ComplianceFailure"
-}
-export interface ClaimTarget {
-    target: string | Identity;
-    claim: Claim;
-    expiry?: Date;
-}
-export declare type SubCallback<T> = (result: T) => void | Promise<void>;
-export declare type UnsubCallback = () => void;
-export interface MiddlewareConfig {
-    link: string;
-    key: string;
-}
-export interface PolkadotConfig {
-    /**
-     * provide a locally saved metadata file for a modestly fast startup time (e.g. 1 second when provided, 1.5 seconds without).
-     *
-     * @note if not provided the SDK will read the needed data from chain during startup
-     *
-     * @note format is key as genesis hash and spec version and the value hex encoded chain metadata
-     *
-     * @example creating valid metadata
-     * ```ts
-     const meta = _polkadotApi.runtimeMetadata.toHex();
-     const genesisHash = _polkadotApi.genesisHash;
-     const specVersion = _polkadotApi.runtimeVersion.specVersion;
-  
-    const metadata = {
-      [`${genesisHash}-${specVersion}`]: meta,
-    };
-    ```
-     */
-    metadata?: ApiOptions['metadata'];
-    /**
-     * set to `true` to disable polkadot start up warnings
-     */
-    noInitWarn?: boolean;
-    /**
-     * allows for types to be provided for multiple chain specs at once
-     *
-     * @note shouldn't be needed for most use cases
-     */
-    typesBundle?: ApiOptions['typesBundle'];
-}
-export interface EventIdentifier {
-    blockNumber: BigNumber;
-    blockHash: string;
-    blockDate: Date;
-    eventIndex: BigNumber;
-}
-export interface Balance {
-    /**
-     * balance available for transferring and paying fees
-     */
-    free: BigNumber;
-    /**
-     * unavailable balance, either bonded for staking or locked for some other purpose
-     */
-    locked: BigNumber;
-    /**
-     * free + locked
-     */
-    total: BigNumber;
-}
-export declare type AccountBalance = Balance;
-export interface PaginationOptions {
-    size: BigNumber;
-    start?: string;
-}
-export declare type NextKey = string | BigNumber | null;
-export interface ResultSet<T> {
-    data: T[];
-    next: NextKey;
-    /**
-     * @note methods will have `count` defined when middleware is configured, but be undefined otherwise. This happens when the chain node is queried directly
-     */
-    count?: BigNumber;
-}
-export interface NetworkProperties {
-    name: string;
-    version: BigNumber;
-}
-export interface Fees {
-    /**
-     * bonus fee charged by certain transactions
-     */
-    protocol: BigNumber;
-    /**
-     * regular network fee
-     */
-    gas: BigNumber;
-    /**
-     * sum of the protocol and gas fees
-     */
-    total: BigNumber;
-}
-/**
- * Type of relationship between a paying account and a beneficiary
- */
-export declare enum PayingAccountType {
-    /**
-     * the paying Account is currently subsidizing the caller
-     */
-    Subsidy = "Subsidy",
-    /**
-     * the paying Account is paying for a specific transaction because of
-     *   chain-specific constraints (e.g. the caller is accepting an invitation to an Identity
-     *   and cannot have any funds to pay for it by definition)
-     */
-    Other = "Other",
-    /**
-     * the caller Account is responsible of paying the fees
-     */
-    Caller = "Caller"
-}
-/**
- * Data representing the Account responsible for paying fees for a transaction
- */
-export declare type PayingAccount = {
-    type: PayingAccountType.Subsidy;
-    /**
-     * Account that pays for the transaction
-     */
-    account: Account;
-    /**
-     * total amount that can be paid for
-     */
-    allowance: BigNumber;
-} | {
-    type: PayingAccountType.Caller | PayingAccountType.Other;
-    account: Account;
-};
-/**
- * Breakdown of the fees that will be paid by a specific Account for a transaction, along
- *   with data associated to the Paying account
- */
-export interface PayingAccountFees {
-    /**
-     * fees that will be paid by the Account
-     */
-    fees: Fees;
-    /**
-     * data related to the Account responsible of paying for the transaction
-     */
-    payingAccountData: PayingAccount & {
-        /**
-         * free balance of the Account
-         */
-        balance: BigNumber;
-    };
-}
-export declare enum SignerType {
-    Identity = "Identity",
-    Account = "Account"
-}
-export interface SignerValue {
-    /**
-     * whether the signer is an Account or Identity
-     */
-    type: SignerType;
-    /**
-     * address or DID (depending on whether the signer is an Account or Identity)
-     */
-    value: string;
-}
-/**
- * Transaction Groups (for permissions purposes)
- */
-export declare enum TxGroup {
-    /**
-     * - TxTags.identity.AddInvestorUniquenessClaim
-     * - TxTags.portfolio.MovePortfolioFunds
-     * - TxTags.settlement.AddInstruction
-     * - TxTags.settlement.AddInstructionWithMemo
-     * - TxTags.settlement.AddAndAffirmInstruction
-     * - TxTags.settlement.AddAndAffirmInstructionWithMemo
-     * - TxTags.settlement.AffirmInstruction
-     * - TxTags.settlement.RejectInstruction
-     * - TxTags.settlement.CreateVenue
-     */
-    PortfolioManagement = "PortfolioManagement",
-    /**
-     * - TxTags.asset.MakeDivisible
-     * - TxTags.asset.RenameAsset
-     * - TxTags.asset.SetFundingRound
-     * - TxTags.asset.AddDocuments
-     * - TxTags.asset.RemoveDocuments
-     */
-    AssetManagement = "AssetManagement",
-    /**
-     * - TxTags.asset.Freeze
-     * - TxTags.asset.Unfreeze
-     * - TxTags.identity.AddAuthorization
-     * - TxTags.identity.RemoveAuthorization
-     */
-    AdvancedAssetManagement = "AdvancedAssetManagement",
-    /**
-     * - TxTags.identity.AddInvestorUniquenessClaim
-     * - TxTags.settlement.CreateVenue
-     * - TxTags.settlement.AddInstruction
-     * - TxTags.settlement.AddInstructionWithMemo
-     * - TxTags.settlement.AddAndAffirmInstruction
-     * - TxTags.settlement.AddAndAffirmInstructionWithMemo
-     */
-    Distribution = "Distribution",
-    /**
-     * - TxTags.asset.Issue
-     */
-    Issuance = "Issuance",
-    /**
-     * - TxTags.complianceManager.AddDefaultTrustedClaimIssuer
-     * - TxTags.complianceManager.RemoveDefaultTrustedClaimIssuer
-     */
-    TrustedClaimIssuersManagement = "TrustedClaimIssuersManagement",
-    /**
-     * - TxTags.identity.AddClaim
-     * - TxTags.identity.RevokeClaim
-     */
-    ClaimsManagement = "ClaimsManagement",
-    /**
-     * - TxTags.complianceManager.AddComplianceRequirement
-     * - TxTags.complianceManager.RemoveComplianceRequirement
-     * - TxTags.complianceManager.PauseAssetCompliance
-     * - TxTags.complianceManager.ResumeAssetCompliance
-     * - TxTags.complianceManager.ResetAssetCompliance
-     */
-    ComplianceRequirementsManagement = "ComplianceRequirementsManagement",
-    /**
-     * - TxTags.checkpoint.CreateSchedule,
-     * - TxTags.checkpoint.RemoveSchedule,
-     * - TxTags.checkpoint.CreateCheckpoint,
-     * - TxTags.corporateAction.InitiateCorporateAction,
-     * - TxTags.capitalDistribution.Distribute,
-     * - TxTags.capitalDistribution.Claim,
-     * - TxTags.identity.AddInvestorUniquenessClaim,
-     */
-    CorporateActionsManagement = "CorporateActionsManagement",
-    /**
-     * - TxTags.sto.CreateFundraiser,
-     * - TxTags.sto.FreezeFundraiser,
-     * - TxTags.sto.Invest,
-     * - TxTags.sto.ModifyFundraiserWindow,
-     * - TxTags.sto.Stop,
-     * - TxTags.sto.UnfreezeFundraiser,
-     * - TxTags.identity.AddInvestorUniquenessClaim,
-     * - TxTags.asset.Issue,
-     * - TxTags.settlement.CreateVenue
-     */
-    StoManagement = "StoManagement"
-}
-export declare enum PermissionType {
-    Include = "Include",
-    Exclude = "Exclude"
-}
-/**
- * Signer/agent permissions for a specific type
- *
- * @param T - type of Permissions (Asset, Transaction, Portfolio, etc)
- */
-export interface SectionPermissions<T> {
-    /**
-     * Values to be included/excluded
-     */
-    values: T[];
-    /**
-     * Whether the permissions are inclusive or exclusive
-     */
-    type: PermissionType;
-}
-/**
- * Permissions related to Transactions. Can include/exclude individual transactions or entire modules
- */
-export interface TransactionPermissions extends SectionPermissions<TxTag | ModuleName> {
-    /**
-     * Transactions to be exempted from inclusion/exclusion. This allows more granularity when
-     *   setting permissions. For example, let's say we want to include only the `asset` and `staking` modules,
-     *   but exclude the `asset.registerTicker` transaction. We could add both modules to `values`, and add
-     *   `TxTags.asset.registerTicker` to `exceptions`
-     */
-    exceptions?: TxTag[];
-}
-/**
- * Permissions a Secondary Key has over the Identity. A null value means the key has
- *   all permissions of that type (e.g. if `assets` is null, the key has permissions over all
- *   of the Identity's Assets)
- */
-export interface Permissions {
-    /**
-     * Assets over which this key has permissions
-     */
-    assets: SectionPermissions<FungibleAsset> | null;
-    /**
-     * Transactions this key can execute
-     */
-    transactions: TransactionPermissions | null;
-    /**
-     * list of Transaction Groups this key can execute. Having permissions over a TxGroup
-     *   means having permissions over every TxTag in said group. Partial group permissions are not
-     *   covered by this value. For a full picture of transaction permissions, see the `transactions` property
-     *
-     * NOTE: If transactions is null, ignore this value
-     */
-    transactionGroups: TxGroup[];
-    portfolios: SectionPermissions<DefaultPortfolio | NumberedPortfolio> | null;
-}
-/**
- * Asset permissions shared by agents in a group
- */
-export declare type GroupPermissions = Pick<Permissions, 'transactions' | 'transactionGroups'>;
-/**
- * All Permission Groups of a specific Asset, separated by `known` and `custom`
- */
-export interface PermissionGroups {
-    known: KnownPermissionGroup[];
-    custom: CustomPermissionGroup[];
-}
-/**
- * This represents positive permissions (i.e. only "includes"). It is used
- *   for specifying procedure requirements and querying if an Account has certain
- *   permissions. Null values represent full permissions in that category
- */
-export interface SimplePermissions {
-    /**
-     * list of required Asset permissions
-     */
-    assets?: BaseAsset[] | null;
-    /**
-     * list of required Transaction permissions
-     */
-    transactions?: TxTag[] | null;
-    portfolios?: (DefaultPortfolio | NumberedPortfolio)[] | null;
-}
-/**
- * Result of a `checkRoles` call
- */
-export interface CheckRolesResult {
-    /**
-     * required roles which the Identity *DOESN'T* have. Only present if `result` is `false`
-     */
-    missingRoles?: Role[];
-    /**
-     * whether the signer possesses all the required roles or not
-     */
-    result: boolean;
-    /**
-     * optional message explaining the reason for failure in special cases
-     */
-    message?: string;
-}
-/**
- * Result of a `checkPermissions` call. If `Type` is `Account`, represents whether the Account
- *   has all the necessary secondary key Permissions. If `Type` is `Identity`, represents whether the
- *   Identity has all the necessary external agent Permissions
- */
-export interface CheckPermissionsResult<Type extends SignerType> {
-    /**
-     * required permissions which the signer *DOESN'T* have. Only present if `result` is `false`
-     */
-    missingPermissions?: Type extends SignerType.Account ? SimplePermissions : TxTag[] | null;
-    /**
-     * whether the signer complies with the required permissions or not
-     */
-    result: boolean;
-    /**
-     * optional message explaining the reason for failure in special cases
-     */
-    message?: string;
-}
-export declare enum PermissionGroupType {
-    /**
-     * all transactions authorized
-     */
-    Full = "Full",
-    /**
-     * not authorized:
-     *   - externalAgents
-     */
-    ExceptMeta = "ExceptMeta",
-    /**
-     * authorized:
-     *   - corporateAction
-     *   - corporateBallot
-     *   - capitalDistribution
-     */
-    PolymeshV1Caa = "PolymeshV1Caa",
-    /**
-     * authorized:
-     *   - asset.issue
-     *   - asset.redeem
-     *   - asset.controllerTransfer
-     *   - sto (except for sto.invest)
-     */
-    PolymeshV1Pia = "PolymeshV1Pia"
-}
-export declare type AttestPrimaryKeyRotationAuthorizationData = {
-    type: AuthorizationType.AttestPrimaryKeyRotation;
-    value: Identity;
-};
-export declare type RotatePrimaryKeyAuthorizationData = {
-    type: AuthorizationType.RotatePrimaryKey;
-};
-export declare type RotatePrimaryKeyToSecondaryData = {
-    type: AuthorizationType.RotatePrimaryKeyToSecondary;
-    value: Permissions;
-};
-export declare type JoinIdentityAuthorizationData = {
-    type: AuthorizationType.JoinIdentity;
-    value: Permissions;
-};
-export declare type PortfolioCustodyAuthorizationData = {
-    type: AuthorizationType.PortfolioCustody;
-    value: NumberedPortfolio | DefaultPortfolio;
-};
-export declare type BecomeAgentAuthorizationData = {
-    type: AuthorizationType.BecomeAgent;
-    value: KnownPermissionGroup | CustomPermissionGroup;
-};
-export declare type AddRelayerPayingKeyAuthorizationData = {
-    type: AuthorizationType.AddRelayerPayingKey;
-    value: SubsidyData;
-};
-export declare type GenericAuthorizationData = {
-    type: Exclude<AuthorizationType, AuthorizationType.RotatePrimaryKey | AuthorizationType.JoinIdentity | AuthorizationType.PortfolioCustody | AuthorizationType.BecomeAgent | AuthorizationType.AddRelayerPayingKey | AuthorizationType.RotatePrimaryKeyToSecondary | AuthorizationType.AttestPrimaryKeyRotation>;
-    value: string;
-};
-/**
- * Authorization request data corresponding to type
- */
-export declare type Authorization = AttestPrimaryKeyRotationAuthorizationData | RotatePrimaryKeyAuthorizationData | JoinIdentityAuthorizationData | PortfolioCustodyAuthorizationData | BecomeAgentAuthorizationData | AddRelayerPayingKeyAuthorizationData | RotatePrimaryKeyToSecondaryData | GenericAuthorizationData;
-export declare enum TransactionArgumentType {
-    Did = "Did",
-    Address = "Address",
-    Text = "Text",
-    Boolean = "Boolean",
-    Number = "Number",
-    Balance = "Balance",
-    Date = "Date",
-    Array = "Array",
-    Tuple = "Tuple",
-    SimpleEnum = "SimpleEnum",
-    RichEnum = "RichEnum",
-    Object = "Object",
-    Unknown = "Unknown",
-    Null = "Null"
-}
-export interface PlainTransactionArgument {
-    type: Exclude<TransactionArgumentType, TransactionArgumentType.Array | TransactionArgumentType.Tuple | TransactionArgumentType.SimpleEnum | TransactionArgumentType.RichEnum | TransactionArgumentType.Object>;
-}
-export interface ArrayTransactionArgument {
-    type: TransactionArgumentType.Array;
-    internal: TransactionArgument;
-}
-export interface SimpleEnumTransactionArgument {
-    type: TransactionArgumentType.SimpleEnum;
-    internal: string[];
-}
-export interface ComplexTransactionArgument {
-    type: TransactionArgumentType.RichEnum | TransactionArgumentType.Object | TransactionArgumentType.Tuple;
-    internal: TransactionArgument[];
-}
-export declare type TransactionArgument = {
-    name: string;
-    optional: boolean;
-    _rawType: TypeDef;
-} & (PlainTransactionArgument | ArrayTransactionArgument | SimpleEnumTransactionArgument | ComplexTransactionArgument);
-export declare type Signer = Identity | Account;
-export interface OfferingWithDetails {
-    offering: Offering;
-    details: OfferingDetails;
-}
-export interface CheckpointWithData {
-    checkpoint: Checkpoint;
-    createdAt: Date;
-    totalSupply: BigNumber;
-}
-export interface PermissionedAccount {
-    account: Account;
-    permissions: Permissions;
-}
-export declare type PortfolioLike = string | Identity | NumberedPortfolio | DefaultPortfolio | {
-    identity: string | Identity;
-    id: BigNumber;
-};
-/**
- * Permissions to grant to a Signer over an Identity
- *
- * {@link Permissions}
- *
- * @note TxGroups in the `transactionGroups` array will be transformed into their corresponding `TxTag`s
- */
-export declare type PermissionsLike = {
-    /**
-     * Assets on which to grant permissions. A null value represents full permissions
-     */
-    assets?: SectionPermissions<string | FungibleAsset> | null;
-    /**
-     * Portfolios on which to grant permissions. A null value represents full permissions
-     */
-    portfolios?: SectionPermissions<PortfolioLike> | null;
-} & ({
-    transactions?: TransactionPermissions | null;
-} | {
-    transactionGroups?: TxGroup[];
-});
-export interface FungiblePortfolioMovement {
-    asset: string | FungibleAsset;
-    amount: BigNumber;
-    /**
-     * identifier string to help differentiate transfers
-     */
-    memo?: string;
-}
-export declare type NonFungiblePortfolioMovement = {
-    asset: NftCollection | string;
-    nfts: (Nft | BigNumber)[];
-    /**
-     * identifier string to help differentiate transfers
-     */
-    memo?: string;
-};
-export declare type PortfolioMovement = FungiblePortfolioMovement | NonFungiblePortfolioMovement;
-export interface ProcedureAuthorizationStatus {
-    /**
-     * whether the Identity complies with all required Agent permissions
-     */
-    agentPermissions: CheckPermissionsResult<SignerType.Identity>;
-    /**
-     * whether the Account complies with all required Signer permissions
-     */
-    signerPermissions: CheckPermissionsResult<SignerType.Account>;
-    /**
-     * whether the Identity complies with all required Roles
-     */
-    roles: CheckRolesResult;
-    /**
-     * whether the Account is frozen (i.e. can't perform any transactions)
-     */
-    accountFrozen: boolean;
-    /**
-     * true only if the Procedure requires an Identity but the signing Account
-     *   doesn't have one associated
-     */
-    noIdentity: boolean;
-}
-interface TransferRestrictionBase {
-    /**
-     * array of Identity IDs that are exempted from the Restriction
-     */
-    exemptedIds?: string[];
-}
-export interface CountTransferRestriction extends TransferRestrictionBase {
-    count: BigNumber;
-}
-export interface PercentageTransferRestriction extends TransferRestrictionBase {
-    /**
-     * maximum percentage (0-100) of the total supply of the Asset that can be held by a single investor at once
-     */
-    percentage: BigNumber;
-}
-export interface ClaimCountTransferRestriction extends TransferRestrictionBase {
-    /**
-     * The type of investors this restriction applies to. e.g. non-accredited
-     */
-    claim: InputStatClaim;
-    /**
-     * The minimum amount of investors the must meet the Claim criteria
-     */
-    min: BigNumber;
-    /**
-     * The maximum amount of investors that must meet the Claim criteria
-     */
-    max?: BigNumber;
-    issuer: Identity;
-}
-export interface ClaimPercentageTransferRestriction extends TransferRestrictionBase {
-    /**
-     * The type of investors this restriction applies to. e.g. Canadian investor
-     */
-    claim: InputStatClaim;
-    /**
-     * The minimum percentage of the total supply that investors meeting the Claim criteria must hold
-     */
-    min: BigNumber;
-    /**
-     * The maximum percentage of the total supply that investors meeting the Claim criteria must hold
-     */
-    max: BigNumber;
-    issuer: Identity;
-}
-export interface ActiveTransferRestrictions<Restriction extends CountTransferRestriction | PercentageTransferRestriction | ClaimCountTransferRestriction | ClaimPercentageTransferRestriction> {
-    restrictions: Restriction[];
-    /**
-     * amount of restrictions that can be added before reaching the shared limit
-     */
-    availableSlots: BigNumber;
-}
-export declare enum TransferRestrictionType {
-    Count = "Count",
-    Percentage = "Percentage",
-    ClaimCount = "ClaimCount",
-    ClaimPercentage = "ClaimPercentage"
-}
-export declare type TransferRestriction = {
-    type: TransferRestrictionType.Count;
-    value: BigNumber;
-} | {
-    type: TransferRestrictionType.Percentage;
-    value: BigNumber;
-} | {
-    type: TransferRestrictionType.ClaimCount;
-    value: ClaimCountRestrictionValue;
-} | {
-    type: TransferRestrictionType.ClaimPercentage;
-    value: ClaimPercentageRestrictionValue;
-};
-export interface ClaimCountRestrictionValue {
-    min: BigNumber;
-    max?: BigNumber;
-    issuer: Identity;
-    claim: InputStatClaim;
-}
-export interface ClaimPercentageRestrictionValue {
-    min: BigNumber;
-    max: BigNumber;
-    issuer: Identity;
-    claim: InputStatClaim;
-}
-export interface AddCountStatInput {
-    count: BigNumber;
-}
-export interface StatClaimIssuer {
-    issuer: Identity;
-    claimType: StatClaimType;
-}
-export declare type ClaimCountStatInput = {
-    issuer: Identity;
-    claimType: ClaimType.Accredited;
-    value: {
-        accredited: BigNumber;
-        nonAccredited: BigNumber;
-    };
-} | {
-    issuer: Identity;
-    claimType: ClaimType.Affiliate;
-    value: {
-        affiliate: BigNumber;
-        nonAffiliate: BigNumber;
-    };
-} | {
-    issuer: Identity;
-    claimType: ClaimType.Jurisdiction;
-    value: {
-        countryCode: CountryCode;
-        count: BigNumber;
-    }[];
-};
-export interface ScheduleWithDetails {
-    schedule: CheckpointSchedule;
-    details: ScheduleDetails;
-}
-export interface DistributionWithDetails {
-    distribution: DividendDistribution;
-    details: DividendDistributionDetails;
-}
-export interface DistributionPayment {
-    blockNumber: BigNumber;
-    blockHash: string;
-    date: Date;
-    target: Identity;
-    amount: BigNumber;
-    /**
-     * percentage (0-100) of tax withholding for the `target` identity
-     */
-    withheldTax: BigNumber;
-}
-export interface ProcedureOpts {
-    /**
-     * Account or address of a signing key to replace the current one (for this procedure only)
-     */
-    signingAccount?: string | Account;
-    /**
-     * nonce value for signing the transaction
-     *
-     * An {@link api/entities/Account!Account} can directly fetch its current nonce by calling {@link api/entities/Account!Account.getCurrentNonce | account.getCurrentNonce}. More information can be found at: https://polkadot.js.org/docs/api/cookbook/tx/#how-do-i-take-the-pending-tx-pool-into-account-in-my-nonce
-     *
-     * @note the passed value can be either the nonce itself or a function that returns the nonce. This allows, for example, passing a closure that increases the returned value every time it's called, or a function that fetches the nonce from the chain or a different source
-     */
-    nonce?: BigNumber | Promise<BigNumber> | (() => BigNumber | Promise<BigNumber>);
-    /**
-     * This option allows for transactions that never expire, aka "immortal". By default, a transaction is only valid for approximately 5 minutes (250 blocks) after its construction. Allows for transaction construction to be decoupled from its submission, such as requiring manual approval for the signing or providing "at least once" guarantees.
-     *
-     * More information can be found [here](https://wiki.polkadot.network/docs/build-protocol-info#transaction-mortality). Note the Polymesh chain will **never** reap Accounts, so the risk of a replay attack is mitigated.
-     */
-    mortality?: MortalityProcedureOpt;
-}
-/**
- * This transaction will never expire
- */
-export interface ImmortalProcedureOptValue {
-    readonly immortal: true;
-}
-/**
- * This transaction will be rejected if not included in a block after a while (default: ~5 minutes)
- */
-export interface MortalProcedureOptValue {
-    readonly immortal: false;
-    /**
-     * The number of blocks the for which the transaction remains valid. Target block time is 6 seconds. The default should suffice for most use cases
-     *
-     * @note this value will get rounded up to the closest power of 2, e.g. `65` rounds up to `128`
-     * @note this value should not exceed 4096, which is the chain's `BlockHashCount` as the lesser of the two will be used.
-     */
-    readonly lifetime?: BigNumber;
-}
-export declare type MortalityProcedureOpt = ImmortalProcedureOptValue | MortalProcedureOptValue;
-export interface CreateTransactionBatchProcedureMethod {
-    <ReturnValues extends readonly [...unknown[]]>(args: CreateTransactionBatchParams<ReturnValues>, opts?: ProcedureOpts): Promise<PolymeshTransactionBatch<ReturnValues, ReturnValues>>;
-    checkAuthorization: <ReturnValues extends [...unknown[]]>(args: CreateTransactionBatchParams<ReturnValues>, opts?: ProcedureOpts) => Promise<ProcedureAuthorizationStatus>;
-}
-export interface ProcedureMethod<MethodArgs, ProcedureReturnValue, ReturnValue = ProcedureReturnValue> {
-    (args: MethodArgs, opts?: ProcedureOpts): Promise<GenericPolymeshTransaction<ProcedureReturnValue, ReturnValue>>;
-    checkAuthorization: (args: MethodArgs, opts?: ProcedureOpts) => Promise<ProcedureAuthorizationStatus>;
-}
-export interface OptionalArgsProcedureMethod<MethodArgs, ProcedureReturnValue, ReturnValue = ProcedureReturnValue> {
-    (args?: MethodArgs, opts?: ProcedureOpts): Promise<GenericPolymeshTransaction<ProcedureReturnValue, ReturnValue>>;
-    checkAuthorization: (args?: MethodArgs, opts?: ProcedureOpts) => Promise<ProcedureAuthorizationStatus>;
-}
-export interface NoArgsProcedureMethod<ProcedureReturnValue, ReturnValue = ProcedureReturnValue> {
-    (opts?: ProcedureOpts): Promise<GenericPolymeshTransaction<ProcedureReturnValue, ReturnValue>>;
-    checkAuthorization: (opts?: ProcedureOpts) => Promise<ProcedureAuthorizationStatus>;
-}
-export interface GroupedInstructions {
-    /**
-     * Instructions that have already been affirmed by the Identity
-     */
-    affirmed: Instruction[];
-    /**
-     * Instructions that still need to be affirmed/rejected by the Identity
-     */
-    pending: Instruction[];
-    /**
-     * Instructions that failed in their execution (can be rescheduled).
-     *   This group supersedes the other three, so for example, a failed Instruction
-     *   might also belong in the `affirmed` group, but it will only be included in this one
-     */
-    failed: Instruction[];
-}
-export declare type InstructionsByStatus = GroupedInstructions & {
-    /**
-     * Instructions that have one or more legs already affirmed, but still need to be one or more legs to be affirmed/rejected by the Identity
-     */
-    partiallyAffirmed: Instruction[];
-};
-export interface GroupedInvolvedInstructions {
-    /**
-     * Instructions where the Identity is the custodian of the leg portfolios
-     */
-    custodied: GroupedInstructions;
-    /**
-     * Instructions where the Identity is the owner of the leg portfolios
-     */
-    owned: Omit<GroupedInstructions, 'affirmed'>;
-}
-export interface AssetWithGroup {
-    asset: FungibleAsset;
-    group: KnownPermissionGroup | CustomPermissionGroup;
-}
-/**
- * Events triggered by transactions performed by an Agent Identity, related to the Token's configuration
- *   For example: changing compliance requirements, inviting/removing agent Identities, freezing/unfreezing transfers
- *
- * Token transfers (settlements or movements between Portfolios) do not count as Operations
- */
-export interface HistoricAgentOperation {
-    /**
-     * Agent Identity that performed the operations
-     */
-    identity: Identity;
-    /**
-     * list of Token Operation Events that were triggered by the Agent Identity
-     */
-    history: EventIdentifier[];
-}
-/**
- * URI|mnemonic|hex representation of a private key
- */
-export declare type PrivateKey = {
-    uri: string;
-} | {
-    mnemonic: string;
-} | {
-    seed: string;
-};
-/**
- * Targets of a corporate action in a flexible structure for input purposes
- */
-export declare type InputCorporateActionTargets = Modify<CorporateActionTargets, {
-    identities: (string | Identity)[];
-}>;
-/**
- * Per-Identity tax withholdings of a corporate action in a flexible structure for input purposes
- */
-export declare type InputCorporateActionTaxWithholdings = Modify<TaxWithholding, {
-    identity: string | Identity;
-}>[];
-export declare type GenericPolymeshTransaction<ProcedureReturnValue, ReturnValue> = PolymeshTransaction<ProcedureReturnValue, ReturnValue> | PolymeshTransactionBatch<ProcedureReturnValue, ReturnValue>;
-export declare type TransactionArray<ReturnValues extends readonly [...unknown[]]> = {
-    [K in keyof ReturnValues]: GenericPolymeshTransaction<any, ReturnValues[K]>;
-};
-/**
- * Transaction data for display purposes
- */
-export interface TxData<Args extends unknown[] = unknown[]> {
-    /**
-     * transaction string identifier
-     */
-    tag: TxTag;
-    /**
-     * arguments with which the transaction will be called
-     */
-    args: Args;
-}
-export interface MiddlewareMetadata {
-    chain: string;
-    genesisHash: string;
-    indexerHealthy: boolean;
-    lastProcessedHeight: BigNumber;
-    lastProcessedTimestamp: Date;
-    specName: string;
-    targetHeight: BigNumber;
-}
-/**
- * Apply the {@link TxData} type to all args in an array
- */
-export declare type MapTxData<ArgsArray extends unknown[][]> = {
-    [K in keyof ArgsArray]: ArgsArray[K] extends unknown[] ? TxData<ArgsArray[K]> : never;
-};
-/**
- *
- */
-export interface SpWeightV2 {
-    refTime: BigNumber;
-    proofSize: BigNumber;
-}
-/**
- * CustomClaimType
- */
-export declare type CustomClaimType = {
-    name: string;
-    id: BigNumber;
-};
-/**
- * Represents JSON serializable data. Used for cases when the value can take on many types, like args for a MultiSig proposal.
- */
-export declare type AnyJson = string | number | boolean | null | undefined | AnyJson[] | {
-    [index: string]: AnyJson;
-};
-/**
- * An nft collection, along with a subset of its NFTs
- */
-export interface HeldNfts {
-    collection: NftCollection;
-    nfts: Nft[];
-}
-/**
- * CustomClaimType with DID that registered the CustomClaimType
- */
-export declare type CustomClaimTypeWithDid = CustomClaimType & {
-    did?: string;
-};
 //# sourceMappingURL=index.d.ts.map