@polkadot/types/interfaces/parachains/types.d.ts

Implementation of the Parity codec

import type { BTreeMap, BitVec, Bytes, Enum, HashMap, Option, Struct, U8aFixed, Vec, bool, u32, u64 } from '@polkadot/types-codec';
import type { ITuple } from '@polkadot/types-codec/types';
import type { Signature } from '@polkadot/types/interfaces/extrinsics';
import type { AccountId, Balance, BalanceOf, BlockNumber, H256, Hash, Header, StorageProof, ValidatorId, Weight } from '@polkadot/types/interfaces/runtime';
import type { MembershipProof, SessionIndex } from '@polkadot/types/interfaces/session';
import type { ValidatorIndex } from '@polkadot/types/interfaces/staking';
/** @name AbridgedCandidateReceipt */
export interface AbridgedCandidateReceipt extends Struct {
    readonly parachainIndex: ParaId;
    readonly relayParent: Hash;
    readonly headData: HeadData;
    readonly collator: CollatorId;
    readonly signature: CollatorSignature;
    readonly povBlockHash: Hash;
    readonly commitments: CandidateCommitments;
}
/** @name AbridgedHostConfiguration */
export interface AbridgedHostConfiguration extends Struct {
    readonly maxCodeSize: u32;
    readonly maxHeadDataSize: u32;
    readonly maxUpwardQueueCount: u32;
    readonly maxUpwardQueueSize: u32;
    readonly maxUpwardMessageSize: u32;
    readonly maxUpwardMessageNumPerCandidate: u32;
    readonly hrmpMaxMessageNumPerCandidate: u32;
    readonly validationUpgradeFrequency: BlockNumber;
    readonly validationUpgradeDelay: BlockNumber;
}
/** @name AbridgedHrmpChannel */
export interface AbridgedHrmpChannel extends Struct {
    readonly maxCapacity: u32;
    readonly maxTotalSize: u32;
    readonly maxMessageSize: u32;
    readonly msgCount: u32;
    readonly totalSize: u32;
    readonly mqcHead: Option<Hash>;
}
/** @name ApprovalVotingParams */
export interface ApprovalVotingParams extends Struct {
    readonly maxApprovalCoalesceCount: u32;
}
/** @name AssignmentId */
export interface AssignmentId extends AccountId {
}
/** @name AssignmentKind */
export interface AssignmentKind extends Enum {
    readonly isParachain: boolean;
    readonly isParathread: boolean;
    readonly asParathread: ITuple<[CollatorId, u32]>;
    readonly type: 'Parachain' | 'Parathread';
}
/** @name AsyncBackingParams */
export interface AsyncBackingParams extends Struct {
    readonly maxCandidateDepth: u32;
    readonly allowedAncestryLen: u32;
}
/** @name AttestedCandidate */
export interface AttestedCandidate extends Struct {
    readonly candidate: AbridgedCandidateReceipt;
    readonly validityVotes: Vec<ValidityAttestation>;
    readonly validatorIndices: BitVec;
}
/** @name AuctionIndex */
export interface AuctionIndex extends u32 {
}
/** @name AuthorityDiscoveryId */
export interface AuthorityDiscoveryId extends AccountId {
}
/** @name AvailabilityBitfield */
export interface AvailabilityBitfield extends BitVec {
}
/** @name AvailabilityBitfieldRecord */
export interface AvailabilityBitfieldRecord extends Struct {
    readonly bitfield: AvailabilityBitfield;
    readonly submittedTt: BlockNumber;
}
/** @name BackedCandidate */
export interface BackedCandidate extends Struct {
    readonly candidate: CommittedCandidateReceipt;
    readonly validityVotes: Vec<ValidityAttestation>;
    readonly validatorIndices: BitVec;
}
/** @name BackingState */
export interface BackingState extends Struct {
    readonly constraints: Constraints;
    readonly pendingAvailability: Vec<CandidatePendingAvailability>;
}
/** @name Bidder */
export interface Bidder extends Enum {
    readonly isNew: boolean;
    readonly asNew: NewBidder;
    readonly isExisting: boolean;
    readonly asExisting: ParaId;
    readonly type: 'New' | 'Existing';
}
/** @name BufferedSessionChange */
export interface BufferedSessionChange extends Struct {
    readonly applyAt: BlockNumber;
    readonly validators: Vec<ValidatorId>;
    readonly queued: Vec<ValidatorId>;
    readonly sessionIndex: SessionIndex;
}
/** @name CandidateCommitments */
export interface CandidateCommitments extends Struct {
    readonly upwardMessages: Vec<UpwardMessage>;
    readonly horizontalMessages: Vec<OutboundHrmpMessage>;
    readonly newValidationCode: Option<ValidationCode>;
    readonly headData: HeadData;
    readonly processedDownwardMessages: u32;
    readonly hrmpWatermark: BlockNumber;
}
/** @name CandidateDescriptor */
export interface CandidateDescriptor extends Struct {
    readonly paraId: ParaId;
    readonly relayParent: RelayChainHash;
    readonly collatorId: CollatorId;
    readonly persistedValidationDataHash: Hash;
    readonly povHash: Hash;
    readonly erasureRoot: Hash;
    readonly signature: CollatorSignature;
    readonly paraHead: Hash;
    readonly validationCodeHash: ValidationCodeHash;
}
/** @name CandidateEvent */
export interface CandidateEvent extends Enum {
    readonly isCandidateBacked: boolean;
    readonly asCandidateBacked: ITuple<[CandidateReceipt, HeadData, CoreIndex, GroupIndex]>;
    readonly isCandidateIncluded: boolean;
    readonly asCandidateIncluded: ITuple<[CandidateReceipt, HeadData, CoreIndex, GroupIndex]>;
    readonly isCandidateTimedOut: boolean;
    readonly asCandidateTimedOut: ITuple<[CandidateReceipt, HeadData, CoreIndex]>;
    readonly type: 'CandidateBacked' | 'CandidateIncluded' | 'CandidateTimedOut';
}
/** @name CandidateHash */
export interface CandidateHash extends Hash {
}
/** @name CandidateInfo */
export interface CandidateInfo extends Struct {
    readonly who: AccountId;
    readonly deposit: Balance;
}
/** @name CandidatePendingAvailability */
export interface CandidatePendingAvailability extends Struct {
    readonly core: CoreIndex;
    readonly hash: CandidateHash;
    readonly descriptor: CandidateDescriptor;
    readonly availabilityVotes: BitVec;
    readonly backers: BitVec;
    readonly relayParentNumber: BlockNumber;
    readonly backedInNumber: BlockNumber;
    readonly backingGroup: GroupIndex;
}
/** @name CandidateReceipt */
export interface CandidateReceipt extends Struct {
    readonly descriptor: CandidateDescriptor;
    readonly commitmentsHash: Hash;
}
/** @name CollatorId */
export interface CollatorId extends H256 {
}
/** @name CollatorSignature */
export interface CollatorSignature extends Signature {
}
/** @name CommittedCandidateReceipt */
export interface CommittedCandidateReceipt extends Struct {
    readonly descriptor: CandidateDescriptor;
    readonly commitments: CandidateCommitments;
}
/** @name Constraints */
export interface Constraints extends Struct {
    readonly minRelayParentNumber: BlockNumber;
    readonly maxPovSize: u32;
    readonly maxCodeSize: u32;
    readonly umpRemaining: u32;
    readonly umpRemainingBytes: u32;
    readonly maxUmpNumPerCandidate: u32;
    readonly dmpRemainingMessages: Vec<BlockNumber>;
    readonly hrmpInbound: InboundHrmpLimitations;
    readonly hrmpChannelsOut: HashMap<ParaId, OutboundHrmpChannelLimitations>;
    readonly maxHrmpNumPerCandidate: u32;
    readonly requiredParent: HeadData;
    readonly validationCodeHash: ValidationCodeHash;
    readonly upgradeRestriction: Option<UpgradeRestriction>;
    readonly futureValidationCode: Option<ITuple<[BlockNumber, ValidationCodeHash]>>;
}
/** @name CoreAssignment */
export interface CoreAssignment extends Struct {
    readonly core: CoreIndex;
    readonly paraId: ParaId;
    readonly kind: AssignmentKind;
    readonly groupIdx: GroupIndex;
}
/** @name CoreIndex */
export interface CoreIndex extends u32 {
}
/** @name CoreOccupied */
export interface CoreOccupied extends Enum {
    readonly isParathread: boolean;
    readonly asParathread: ParathreadEntry;
    readonly isParachain: boolean;
    readonly type: 'Parathread' | 'Parachain';
}
/** @name CoreState */
export interface CoreState extends Enum {
    readonly isOccupied: boolean;
    readonly asOccupied: OccupiedCore;
    readonly isScheduled: boolean;
    readonly asScheduled: ScheduledCore;
    readonly isFree: boolean;
    readonly type: 'Occupied' | 'Scheduled' | 'Free';
}
/** @name DisputeLocation */
export interface DisputeLocation extends Enum {
    readonly isLocal: boolean;
    readonly isRemote: boolean;
    readonly type: 'Local' | 'Remote';
}
/** @name DisputeProof */
export interface DisputeProof extends Struct {
    readonly timeSlot: DisputesTimeSlot;
    readonly kind: SlashingOffenceKind;
    readonly validatorIndex: ValidatorIndex;
    readonly validatorId: ValidatorId;
}
/** @name DisputeResult */
export interface DisputeResult extends Enum {
    readonly isValid: boolean;
    readonly isInvalid: boolean;
    readonly type: 'Valid' | 'Invalid';
}
/** @name DisputeState */
export interface DisputeState extends Struct {
    readonly validatorsFor: BitVec;
    readonly validatorsAgainst: BitVec;
    readonly start: BlockNumber;
    readonly concludedAt: Option<BlockNumber>;
}
/** @name DisputeStatement */
export interface DisputeStatement extends Enum {
    readonly isValid: boolean;
    readonly asValid: ValidDisputeStatementKind;
    readonly isInvalid: boolean;
    readonly asInvalid: InvalidDisputeStatementKind;
    readonly type: 'Valid' | 'Invalid';
}
/** @name DisputeStatementSet */
export interface DisputeStatementSet extends Struct {
    readonly candidateHash: CandidateHash;
    readonly session: SessionIndex;
    readonly statements: Vec<ITuple<[DisputeStatement, ParaValidatorIndex, ValidatorSignature]>>;
}
/** @name DisputesTimeSlot */
export interface DisputesTimeSlot extends Struct {
    readonly sessionIndex: SessionIndex;
    readonly candidateHash: CandidateHash;
}
/** @name DoubleVoteReport */
export interface DoubleVoteReport extends Struct {
    readonly identity: ValidatorId;
    readonly first: ITuple<[Statement, ValidatorSignature]>;
    readonly second: ITuple<[Statement, ValidatorSignature]>;
    readonly proof: MembershipProof;
    readonly signingContext: SigningContext;
}
/** @name DownwardMessage */
export interface DownwardMessage extends Bytes {
}
/** @name ExecutorParam */
export interface ExecutorParam extends Enum {
    readonly isPhantom: boolean;
    readonly isMaxMemoryPages: boolean;
    readonly asMaxMemoryPages: u32;
    readonly isStackLogicalMax: boolean;
    readonly asStackLogicalMax: u32;
    readonly isStackNativeMax: boolean;
    readonly asStackNativeMax: u32;
    readonly isPrecheckingMaxMemory: boolean;
    readonly asPrecheckingMaxMemory: u64;
    readonly isPvfPrepTimeout: boolean;
    readonly asPvfPrepTimeout: ITuple<[PvfPrepTimeoutKind, u64]>;
    readonly isPvfExecTimeout: boolean;
    readonly asPvfExecTimeout: ITuple<[PvfExecTimeoutKind, u64]>;
    readonly type: 'Phantom' | 'MaxMemoryPages' | 'StackLogicalMax' | 'StackNativeMax' | 'PrecheckingMaxMemory' | 'PvfPrepTimeout' | 'PvfExecTimeout';
}
/** @name ExecutorParams */
export interface ExecutorParams extends Vec<ExecutorParam> {
}
/** @name ExecutorParamsHash */
export interface ExecutorParamsHash extends Hash {
}
/** @name ExplicitDisputeStatement */
export interface ExplicitDisputeStatement extends Struct {
    readonly valid: bool;
    readonly candidateHash: CandidateHash;
    readonly session: SessionIndex;
}
/** @name GlobalValidationData */
export interface GlobalValidationData extends Struct {
    readonly maxCodeSize: u32;
    readonly maxHeadDataSize: u32;
    readonly blockNumber: BlockNumber;
}
/** @name GlobalValidationSchedule */
export interface GlobalValidationSchedule extends Struct {
    readonly maxCodeSize: u32;
    readonly maxHeadDataSize: u32;
    readonly blockNumber: BlockNumber;
}
/** @name GroupIndex */
export interface GroupIndex extends u32 {
}
/** @name GroupRotationInfo */
export interface GroupRotationInfo extends Struct {
    readonly sessionStartBlock: BlockNumber;
    readonly groupRotationFrequency: BlockNumber;
    readonly now: BlockNumber;
}
/** @name HeadData */
export interface HeadData extends Bytes {
}
/** @name HostConfiguration */
export interface HostConfiguration extends Struct {
    readonly maxCodeSize: u32;
    readonly maxHeadDataSize: u32;
    readonly maxUpwardQueueCount: u32;
    readonly maxUpwardQueueSize: u32;
    readonly maxUpwardMessageSize: u32;
    readonly maxUpwardMessageNumPerCandidate: u32;
    readonly hrmpMaxMessageNumPerCandidate: u32;
    readonly validationUpgradeFrequency: BlockNumber;
    readonly validationUpgradeDelay: BlockNumber;
    readonly maxPovSize: u32;
    readonly maxDownwardMessageSize: u32;
    readonly preferredDispatchableUpwardMessagesStepWeight: Weight;
    readonly hrmpMaxParachainOutboundChannels: u32;
    readonly hrmpMaxParathreadOutboundChannels: u32;
    readonly hrmpOpenRequestTtl: u32;
    readonly hrmpSenderDeposit: Balance;
    readonly hrmpRecipientDeposit: Balance;
    readonly hrmpChannelMaxCapacity: u32;
    readonly hrmpChannelMaxTotalSize: u32;
    readonly hrmpMaxParachainInboundChannels: u32;
    readonly hrmpMaxParathreadInboundChannels: u32;
    readonly hrmpChannelMaxMessageSize: u32;
    readonly codeRetentionPeriod: BlockNumber;
    readonly parathreadCores: u32;
    readonly parathreadRetries: u32;
    readonly groupRotationFrequency: BlockNumber;
    readonly chainAvailabilityPeriod: BlockNumber;
    readonly threadAvailabilityPeriod: BlockNumber;
    readonly schedulingLookahead: u32;
    readonly maxValidatorsPerCore: Option<u32>;
    readonly maxValidators: Option<u32>;
    readonly disputePeriod: SessionIndex;
    readonly disputePostConclusionAcceptancePeriod: BlockNumber;
    readonly disputeMaxSpamSlots: u32;
    readonly disputeConclusionByTimeOutPeriod: BlockNumber;
    readonly noShowSlots: u32;
    readonly nDelayTranches: u32;
    readonly zerothDelayTrancheWidth: u32;
    readonly neededApprovals: u32;
    readonly relayVrfModuloSamples: u32;
}
/** @name HrmpChannel */
export interface HrmpChannel extends Struct {
    readonly maxCapacity: u32;
    readonly maxTotalSize: u32;
    readonly maxMessageSize: u32;
    readonly msgCount: u32;
    readonly totalSize: u32;
    readonly mqcHead: Option<Hash>;
    readonly senderDeposit: Balance;
    readonly recipientDeposit: Balance;
}
/** @name HrmpChannelId */
export interface HrmpChannelId extends Struct {
    readonly sender: u32;
    readonly receiver: u32;
}
/** @name HrmpOpenChannelRequest */
export interface HrmpOpenChannelRequest extends Struct {
    readonly confirmed: bool;
    readonly age: SessionIndex;
    readonly senderDeposit: Balance;
    readonly maxMessageSize: u32;
    readonly maxCapacity: u32;
    readonly maxTotalSize: u32;
}
/** @name InboundDownwardMessage */
export interface InboundDownwardMessage extends Struct {
    readonly pubSentAt: BlockNumber;
    readonly pubMsg: DownwardMessage;
}
/** @name InboundHrmpLimitations */
export interface InboundHrmpLimitations extends Struct {
    readonly validWatermarks: Vec<BlockNumber>;
}
/** @name InboundHrmpMessage */
export interface InboundHrmpMessage extends Struct {
    readonly sentAt: BlockNumber;
    readonly data: Bytes;
}
/** @name InboundHrmpMessages */
export interface InboundHrmpMessages extends Vec<InboundHrmpMessage> {
}
/** @name IncomingParachain */
export interface IncomingParachain extends Enum {
    readonly isUnset: boolean;
    readonly asUnset: NewBidder;
    readonly isFixed: boolean;
    readonly asFixed: IncomingParachainFixed;
    readonly isDeploy: boolean;
    readonly asDeploy: IncomingParachainDeploy;
    readonly type: 'Unset' | 'Fixed' | 'Deploy';
}
/** @name IncomingParachainDeploy */
export interface IncomingParachainDeploy extends Struct {
    readonly code: ValidationCode;
    readonly initialHeadData: HeadData;
}
/** @name IncomingParachainFixed */
export interface IncomingParachainFixed extends Struct {
    readonly codeHash: Hash;
    readonly codeSize: u32;
    readonly initialHeadData: HeadData;
}
/** @name InvalidDisputeStatementKind */
export interface InvalidDisputeStatementKind extends Enum {
    readonly isExplicit: boolean;
    readonly type: 'Explicit';
}
/** @name LeasePeriod */
export interface LeasePeriod extends BlockNumber {
}
/** @name LeasePeriodOf */
export interface LeasePeriodOf extends BlockNumber {
}
/** @name LocalValidationData */
export interface LocalValidationData extends Struct {
    readonly parentHead: HeadData;
    readonly balance: Balance;
    readonly codeUpgradeAllowed: Option<BlockNumber>;
}
/** @name MessageIngestionType */
export interface MessageIngestionType extends Struct {
    readonly downwardMessages: Vec<InboundDownwardMessage>;
    readonly horizontalMessages: BTreeMap<ParaId, InboundHrmpMessages>;
}
/** @name MessageQueueChain */
export interface MessageQueueChain extends RelayChainHash {
}
/** @name MessagingStateSnapshot */
export interface MessagingStateSnapshot extends Struct {
    readonly relayDispatchQueueSize: ITuple<[u32, u32]>;
    readonly egressChannels: Vec<MessagingStateSnapshotEgressEntry>;
}
/** @name MessagingStateSnapshotEgressEntry */
export interface MessagingStateSnapshotEgressEntry extends ITuple<[ParaId, AbridgedHrmpChannel]> {
}
/** @name MultiDisputeStatementSet */
export interface MultiDisputeStatementSet extends Vec<DisputeStatementSet> {
}
/** @name NewBidder */
export interface NewBidder extends Struct {
    readonly who: AccountId;
    readonly sub: SubId;
}
/** @name NodeFeatures */
export interface NodeFeatures extends BitVec {
}
/** @name OccupiedCore */
export interface OccupiedCore extends Struct {
    readonly nextUpOnAvailable: Option<ScheduledCore>;
    readonly occupiedSince: BlockNumber;
    readonly timeOutAt: BlockNumber;
    readonly nextUpOnTimeOut: Option<ScheduledCore>;
    readonly availability: BitVec;
    readonly groupResponsible: GroupIndex;
    readonly candidateHash: CandidateHash;
    readonly candidateDescriptor: CandidateDescriptor;
}
/** @name OccupiedCoreAssumption */
export interface OccupiedCoreAssumption extends Enum {
    readonly isIncluded: boolean;
    readonly isTimedOut: boolean;
    readonly isFree: boolean;
    readonly type: 'Included' | 'TimedOut' | 'Free';
}
/** @name OldV1SessionInfo */
export interface OldV1SessionInfo extends Struct {
    readonly validators: Vec<ValidatorId>;
    readonly discoveryKeys: Vec<AuthorityDiscoveryId>;
    readonly assignmentKeys: Vec<AssignmentId>;
    readonly validatorGroups: Vec<Vec<ParaValidatorIndex>>;
    readonly nCores: u32;
    readonly zerothDelayTrancheWidth: u32;
    readonly relayVrfModuloSamples: u32;
    readonly nDelayTranches: u32;
    readonly noShowSlots: u32;
    readonly neededApprovals: u32;
}
/** @name OutboundHrmpChannelLimitations */
export interface OutboundHrmpChannelLimitations extends Struct {
    readonly bytesRemaining: u32;
    readonly messagesRemaining: u32;
}
/** @name OutboundHrmpMessage */
export interface OutboundHrmpMessage extends Struct {
    readonly recipient: u32;
    readonly data: Bytes;
}
/** @name ParachainDispatchOrigin */
export interface ParachainDispatchOrigin extends Enum {
    readonly isSigned: boolean;
    readonly isParachain: boolean;
    readonly isRoot: boolean;
    readonly type: 'Signed' | 'Parachain' | 'Root';
}
/** @name ParachainInherentData */
export interface ParachainInherentData extends Struct {
    readonly validationData: PersistedValidationData;
    readonly relayChainState: StorageProof;
    readonly downwardMessages: Vec<InboundDownwardMessage>;
    readonly horizontalMessages: BTreeMap<ParaId, VecInboundHrmpMessage>;
}
/** @name ParachainProposal */
export interface ParachainProposal extends Struct {
    readonly proposer: AccountId;
    readonly genesisHead: HeadData;
    readonly validators: Vec<ValidatorId>;
    readonly name: Bytes;
    readonly balance: Balance;
}
/** @name ParachainsInherentData */
export interface ParachainsInherentData extends Struct {
    readonly bitfields: SignedAvailabilityBitfields;
    readonly backedCandidates: Vec<BackedCandidate>;
    readonly disputes: MultiDisputeStatementSet;
    readonly parentHeader: Header;
}
/** @name ParaGenesisArgs */
export interface ParaGenesisArgs extends Struct {
    readonly genesisHead: Bytes;
    readonly validationCode: Bytes;
    readonly parachain: bool;
}
/** @name ParaId */
export interface ParaId extends u32 {
}
/** @name ParaInfo */
export interface ParaInfo extends Struct {
    readonly manager: AccountId;
    readonly deposit: Balance;
    readonly locked: bool;
}
/** @name ParaLifecycle */
export interface ParaLifecycle extends Enum {
    readonly isOnboarding: boolean;
    readonly isParathread: boolean;
    readonly isParachain: boolean;
    readonly isUpgradingToParachain: boolean;
    readonly isDowngradingToParathread: boolean;
    readonly isOutgoingParathread: boolean;
    readonly isOutgoingParachain: boolean;
    readonly type: 'Onboarding' | 'Parathread' | 'Parachain' | 'UpgradingToParachain' | 'DowngradingToParathread' | 'OutgoingParathread' | 'OutgoingParachain';
}
/** @name ParaPastCodeMeta */
export interface ParaPastCodeMeta extends Struct {
    readonly upgradeTimes: Vec<ReplacementTimes>;
    readonly lastPruned: Option<BlockNumber>;
}
/** @name ParaScheduling */
export interface ParaScheduling extends Enum {
    readonly isAlways: boolean;
    readonly isDynamic: boolean;
    readonly type: 'Always' | 'Dynamic';
}
/** @name ParathreadClaim */
export interface ParathreadClaim extends ITuple<[ParaId, CollatorId]> {
}
/** @name ParathreadClaimQueue */
export interface ParathreadClaimQueue extends Struct {
    readonly queue: Vec<QueuedParathread>;
    readonly nextCoreOffset: u32;
}
/** @name ParathreadEntry */
export interface ParathreadEntry extends Struct {
    readonly claim: ParathreadClaim;
    readonly retries: u32;
}
/** @name ParaValidatorIndex */
export interface ParaValidatorIndex extends u32 {
}
/** @name PendingSlashes */
export interface PendingSlashes extends Struct {
    readonly slashKeys: BTreeMap<ValidatorIndex, ValidatorId>;
    readonly kind: SlashingOffenceKind;
}
/** @name PersistedValidationData */
export interface PersistedValidationData extends Struct {
    readonly parentHead: HeadData;
    readonly relayParentNumber: RelayChainBlockNumber;
    readonly relayParentStorageRoot: Hash;
    readonly maxPovSize: u32;
}
/** @name PvfCheckStatement */
export interface PvfCheckStatement extends Struct {
    readonly accept: bool;
    readonly subject: ValidationCodeHash;
    readonly sessionIndex: SessionIndex;
    readonly validatorIndex: ParaValidatorIndex;
}
/** @name PvfExecTimeoutKind */
export interface PvfExecTimeoutKind extends Enum {
    readonly isBacking: boolean;
    readonly isApproval: boolean;
    readonly type: 'Backing' | 'Approval';
}
/** @name PvfPrepTimeoutKind */
export interface PvfPrepTimeoutKind extends Enum {
    readonly isPrecheck: boolean;
    readonly isLenient: boolean;
    readonly type: 'Precheck' | 'Lenient';
}
/** @name QueuedParathread */
export interface QueuedParathread extends Struct {
    readonly claim: ParathreadEntry;
    readonly coreOffset: u32;
}
/** @name RegisteredParachainInfo */
export interface RegisteredParachainInfo extends Struct {
    readonly validators: Vec<ValidatorId>;
    readonly proposer: AccountId;
}
/** @name RelayBlockNumber */
export interface RelayBlockNumber extends u32 {
}
/** @name RelayChainBlockNumber */
export interface RelayChainBlockNumber extends RelayBlockNumber {
}
/** @name RelayChainHash */
export interface RelayChainHash extends RelayHash {
}
/** @name RelayHash */
export interface RelayHash extends Hash {
}
/** @name Remark */
export interface Remark extends U8aFixed {
}
/** @name ReplacementTimes */
export interface ReplacementTimes extends Struct {
    readonly expectedAt: BlockNumber;
    readonly activatedAt: BlockNumber;
}
/** @name Retriable */
export interface Retriable extends Enum {
    readonly isNever: boolean;
    readonly isWithRetries: boolean;
    readonly asWithRetries: u32;
    readonly type: 'Never' | 'WithRetries';
}
/** @name ScheduledCore */
export interface ScheduledCore extends Struct {
    readonly paraId: ParaId;
    readonly collator: Option<CollatorId>;
}
/** @name Scheduling */
export interface Scheduling extends Enum {
    readonly isAlways: boolean;
    readonly isDynamic: boolean;
    readonly type: 'Always' | 'Dynamic';
}
/** @name ScrapedOnChainVotes */
export interface ScrapedOnChainVotes extends Struct {
    readonly session: SessionIndex;
    readonly backingValidatorsPerCandidate: Vec<ITuple<[CandidateReceipt, Vec<ITuple<[ParaValidatorIndex, ValidityAttestation]>>]>>;
    readonly disputes: MultiDisputeStatementSet;
}
/** @name ServiceQuality */
export interface ServiceQuality extends Enum {
    readonly isOrdered: boolean;
    readonly isFast: boolean;
    readonly type: 'Ordered' | 'Fast';
}
/** @name SessionInfo */
export interface SessionInfo extends Struct {
    readonly activeValidatorIndices: Vec<ParaValidatorIndex>;
    readonly randomSeed: U8aFixed;
    readonly disputePeriod: SessionIndex;
    readonly validators: Vec<ValidatorId>;
    readonly discoveryKeys: Vec<AuthorityDiscoveryId>;
    readonly assignmentKeys: Vec<AssignmentId>;
    readonly validatorGroups: Vec<Vec<ValidatorIndex>>;
    readonly nCores: u32;
    readonly zerothDelayTrancheWidth: u32;
    readonly relayVrfModuloSamples: u32;
    readonly nDelayTranches: u32;
    readonly noShowSlots: u32;
    readonly neededApprovals: u32;
}
/** @name SessionInfoValidatorGroup */
export interface SessionInfoValidatorGroup extends Vec<ParaValidatorIndex> {
}
/** @name SignedAvailabilityBitfield */
export interface SignedAvailabilityBitfield extends Struct {
    readonly payload: BitVec;
    readonly validatorIndex: ParaValidatorIndex;
    readonly signature: ValidatorSignature;
}
/** @name SignedAvailabilityBitfields */
export interface SignedAvailabilityBitfields extends Vec<SignedAvailabilityBitfield> {
}
/** @name SigningContext */
export interface SigningContext extends Struct {
    readonly sessionIndex: SessionIndex;
    readonly parentHash: Hash;
}
/** @name SlashingOffenceKind */
export interface SlashingOffenceKind extends Enum {
    readonly isForInvalid: boolean;
    readonly isAgainstValid: boolean;
    readonly type: 'ForInvalid' | 'AgainstValid';
}
/** @name SlotRange */
export interface SlotRange extends Enum {
    readonly isZeroZero: boolean;
    readonly isZeroOne: boolean;
    readonly isZeroTwo: boolean;
    readonly isZeroThree: boolean;
    readonly isZeroFour: boolean;
    readonly isZeroFive: boolean;
    readonly isZeroSix: boolean;
    readonly isZeroSeven: boolean;
    readonly isOneOne: boolean;
    readonly isOneTwo: boolean;
    readonly isOneThree: boolean;
    readonly isOneFour: boolean;
    readonly isOneFive: boolean;
    readonly isOneSix: boolean;
    readonly isOneSeven: boolean;
    readonly isTwoTwo: boolean;
    readonly isTwoThree: boolean;
    readonly isTwoFour: boolean;
    readonly isTwoFive: boolean;
    readonly isTwoSix: boolean;
    readonly isTwoSeven: boolean;
    readonly isThreeThree: boolean;
    readonly isThreeFour: boolean;
    readonly isThreeFive: boolean;
    readonly isThreeSix: boolean;
    readonly isThreeSeven: boolean;
    readonly isFourFour: boolean;
    readonly isFourFive: boolean;
    readonly isFourSix: boolean;
    readonly isFourSeven: boolean;
    readonly isFiveFive: boolean;
    readonly isFiveSix: boolean;
    readonly isFiveSeven: boolean;
    readonly isSixSix: boolean;
    readonly isSixSeven: boolean;
    readonly isSevenSeven: boolean;
    readonly type: 'ZeroZero' | 'ZeroOne' | 'ZeroTwo' | 'ZeroThree' | 'ZeroFour' | 'ZeroFive' | 'ZeroSix' | 'ZeroSeven' | 'OneOne' | 'OneTwo' | 'OneThree' | 'OneFour' | 'OneFive' | 'OneSix' | 'OneSeven' | 'TwoTwo' | 'TwoThree' | 'TwoFour' | 'TwoFive' | 'TwoSix' | 'TwoSeven' | 'ThreeThree' | 'ThreeFour' | 'ThreeFive' | 'ThreeSix' | 'ThreeSeven' | 'FourFour' | 'FourFive' | 'FourSix' | 'FourSeven' | 'FiveFive' | 'FiveSix' | 'FiveSeven' | 'SixSix' | 'SixSeven' | 'SevenSeven';
}
/** @name SlotRange10 */
export interface SlotRange10 extends Enum {
    readonly isZeroZero: boolean;
    readonly isZeroOne: boolean;
    readonly isZeroTwo: boolean;
    readonly isZeroThree: boolean;
    readonly isOneOne: boolean;
    readonly isOneTwo: boolean;
    readonly isOneThree: boolean;
    readonly isTwoTwo: boolean;
    readonly isTwoThree: boolean;
    readonly isThreeThree: boolean;
    readonly type: 'ZeroZero' | 'ZeroOne' | 'ZeroTwo' | 'ZeroThree' | 'OneOne' | 'OneTwo' | 'OneThree' | 'TwoTwo' | 'TwoThree' | 'ThreeThree';
}
/** @name Statement */
export interface Statement extends Enum {
    readonly isNever: boolean;
    readonly isCandidate: boolean;
    readonly asCandidate: Hash;
    readonly isValid: boolean;
    readonly asValid: Hash;
    readonly isInvalid: boolean;
    readonly asInvalid: Hash;
    readonly type: 'Never' | 'Candidate' | 'Valid' | 'Invalid';
}
/** @name SubId */
export interface SubId extends u32 {
}
/** @name SystemInherentData */
export interface SystemInherentData extends ParachainInherentData {
}
/** @name TransientValidationData */
export interface TransientValidationData extends Struct {
    readonly maxCodeSize: u32;
    readonly maxHeadDataSize: u32;
    readonly balance: Balance;
    readonly codeUpgradeAllowed: Option<BlockNumber>;
    readonly dmqLength: u32;
}
/** @name UpgradeGoAhead */
export interface UpgradeGoAhead extends Enum {
    readonly isAbort: boolean;
    readonly isGoAhead: boolean;
    readonly type: 'Abort' | 'GoAhead';
}
/** @name UpgradeRestriction */
export interface UpgradeRestriction extends Enum {
    readonly isPresent: boolean;
    readonly type: 'Present';
}
/** @name UpwardMessage */
export interface UpwardMessage extends Bytes {
}
/** @name ValidationCode */
export interface ValidationCode extends Bytes {
}
/** @name ValidationCodeHash */
export interface ValidationCodeHash extends Hash {
}
/** @name ValidationData */
export interface ValidationData extends Struct {
    readonly persisted: PersistedValidationData;
    readonly transient: TransientValidationData;
}
/** @name ValidationDataType */
export interface ValidationDataType extends Struct {
    readonly validationData: ValidationData;
    readonly relayChainState: Vec<Bytes>;
}
/** @name ValidationFunctionParams */
export interface ValidationFunctionParams extends Struct {
    readonly maxCodeSize: u32;
    readonly relayChainHeight: RelayChainBlockNumber;
    readonly codeUpgradeAllowed: Option<RelayChainBlockNumber>;
}
/** @name ValidatorSignature */
export interface ValidatorSignature extends Signature {
}
/** @name ValidDisputeStatementKind */
export interface ValidDisputeStatementKind extends Enum {
    readonly isExplicit: boolean;
    readonly isBackingSeconded: boolean;
    readonly asBackingSeconded: Hash;
    readonly isBackingValid: boolean;
    readonly asBackingValid: Hash;
    readonly isApprovalChecking: boolean;
    readonly type: 'Explicit' | 'BackingSeconded' | 'BackingValid' | 'ApprovalChecking';
}
/** @name ValidityAttestation */
export interface ValidityAttestation extends Enum {
    readonly isNever: boolean;
    readonly isImplicit: boolean;
    readonly asImplicit: ValidatorSignature;
    readonly isExplicit: boolean;
    readonly asExplicit: ValidatorSignature;
    readonly type: 'Never' | 'Implicit' | 'Explicit';
}
/** @name VecInboundHrmpMessage */
export interface VecInboundHrmpMessage extends Vec<InboundHrmpMessage> {
}
/** @name WinnersData */
export interface WinnersData extends Vec<WinnersDataTuple> {
}
/** @name WinnersData10 */
export interface WinnersData10 extends Vec<WinnersDataTuple10> {
}
/** @name WinnersDataTuple */
export interface WinnersDataTuple extends ITuple<[AccountId, ParaId, BalanceOf, SlotRange]> {
}
/** @name WinnersDataTuple10 */
export interface WinnersDataTuple10 extends ITuple<[AccountId, ParaId, BalanceOf, SlotRange10]> {
}
/** @name WinningData */
export interface WinningData extends Vec<WinningDataEntry> {
}
/** @name WinningData10 */
export interface WinningData10 extends Vec<WinningDataEntry> {
}
/** @name WinningDataEntry */
export interface WinningDataEntry extends Option<ITuple<[AccountId, ParaId, BalanceOf]>> {
}
export type PHANTOM_PARACHAINS = 'parachains';