// Copyright (C) Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: Apache-2.0

#![cfg_attr(not(feature = "std"), no_std)]

//! Polkadot SDK umbrella crate re-exporting all other published crates.
//!
//! This helps to set a single version number for all your dependencies. Docs are in the
//! `polkadot-sdk-docs` crate.

// This file is auto-generated and checked by the CI.  You can edit it manually, but it must be
// exactly the way that the CI expects it.

/// Test utils for Asset Hub runtimes.
#[cfg(feature = "asset-test-utils")]
pub use asset_test_utils;

/// Assets common utilities.
#[cfg(feature = "assets-common")]
pub use assets_common;

/// A no-std/Substrate compatible library to construct binary merkle tree.
#[cfg(feature = "binary-merkle-tree")]
pub use binary_merkle_tree;

/// A common interface for describing what a bridge pallet should be able to do.
#[cfg(feature = "bp-header-chain")]
pub use bp_header_chain;

/// Primitives of messages module.
#[cfg(feature = "bp-messages")]
pub use bp_messages;

/// Primitives of parachains module.
#[cfg(feature = "bp-parachains")]
pub use bp_parachains;

/// Primitives of Polkadot runtime.
#[cfg(feature = "bp-polkadot")]
pub use bp_polkadot;

/// Primitives of Polkadot-like runtime.
#[cfg(feature = "bp-polkadot-core")]
pub use bp_polkadot_core;

/// Primitives of relayers module.
#[cfg(feature = "bp-relayers")]
pub use bp_relayers;

/// Primitives that may be used at (bridges) runtime level.
#[cfg(feature = "bp-runtime")]
pub use bp_runtime;

/// Utilities for testing substrate-based runtime bridge code.
#[cfg(feature = "bp-test-utils")]
pub use bp_test_utils;

/// Primitives of the xcm-bridge-hub pallet.
#[cfg(feature = "bp-xcm-bridge-hub")]
pub use bp_xcm_bridge_hub;

/// Primitives of the xcm-bridge-hub fee pallet.
#[cfg(feature = "bp-xcm-bridge-hub-router")]
pub use bp_xcm_bridge_hub_router;

/// Bridge hub common utilities.
#[cfg(feature = "bridge-hub-common")]
pub use bridge_hub_common;

/// Utils for BridgeHub testing.
#[cfg(feature = "bridge-hub-test-utils")]
pub use bridge_hub_test_utils;

/// Common types and functions that may be used by substrate-based runtimes of all bridged
/// chains.
#[cfg(feature = "bridge-runtime-common")]
pub use bridge_runtime_common;

/// Parachain node CLI utilities.
#[cfg(feature = "cumulus-client-cli")]
pub use cumulus_client_cli;

/// Common node-side functionality and glue code to collate parachain blocks.
#[cfg(feature = "cumulus-client-collator")]
pub use cumulus_client_collator;

/// AURA consensus algorithm for parachains.
#[cfg(feature = "cumulus-client-consensus-aura")]
pub use cumulus_client_consensus_aura;

/// Cumulus specific common consensus implementations.
#[cfg(feature = "cumulus-client-consensus-common")]
pub use cumulus_client_consensus_common;

/// A Substrate `Proposer` for building parachain blocks.
#[cfg(feature = "cumulus-client-consensus-proposer")]
pub use cumulus_client_consensus_proposer;

/// The relay-chain provided consensus algorithm.
#[cfg(feature = "cumulus-client-consensus-relay-chain")]
pub use cumulus_client_consensus_relay_chain;

/// Cumulus-specific networking protocol.
#[cfg(feature = "cumulus-client-network")]
pub use cumulus_client_network;

/// Inherent that needs to be present in every parachain block. Contains messages and a relay
/// chain storage-proof.
#[cfg(feature = "cumulus-client-parachain-inherent")]
pub use cumulus_client_parachain_inherent;

/// Parachain PoV recovery.
#[cfg(feature = "cumulus-client-pov-recovery")]
pub use cumulus_client_pov_recovery;

/// Common functions used to assemble the components of a parachain node.
#[cfg(feature = "cumulus-client-service")]
pub use cumulus_client_service;

/// AURA consensus extension pallet for parachains.
#[cfg(feature = "cumulus-pallet-aura-ext")]
pub use cumulus_pallet_aura_ext;

/// Migrates messages from the old DMP queue pallet.
#[cfg(feature = "cumulus-pallet-dmp-queue")]
pub use cumulus_pallet_dmp_queue;

/// Base pallet for cumulus-based parachains.
#[cfg(feature = "cumulus-pallet-parachain-system")]
pub use cumulus_pallet_parachain_system;

/// Proc macros provided by the parachain-system pallet.
#[cfg(feature = "cumulus-pallet-parachain-system-proc-macro")]
pub use cumulus_pallet_parachain_system_proc_macro;

/// FRAME sessions pallet benchmarking.
#[cfg(feature = "cumulus-pallet-session-benchmarking")]
pub use cumulus_pallet_session_benchmarking;

/// Adds functionality to migrate from a Solo to a Parachain.
#[cfg(feature = "cumulus-pallet-solo-to-para")]
pub use cumulus_pallet_solo_to_para;

/// pallet and transaction extensions for accurate proof size reclaim.
#[cfg(feature = "cumulus-pallet-weight-reclaim")]
pub use cumulus_pallet_weight_reclaim;

/// Pallet for stuff specific to parachains' usage of XCM.
#[cfg(feature = "cumulus-pallet-xcm")]
pub use cumulus_pallet_xcm;

/// Pallet to queue outbound and inbound XCMP messages.
#[cfg(feature = "cumulus-pallet-xcmp-queue")]
pub use cumulus_pallet_xcmp_queue;

/// Ping Pallet for Cumulus XCM/UMP testing.
#[cfg(feature = "cumulus-ping")]
pub use cumulus_ping;

/// Core primitives for Aura in Cumulus.
#[cfg(feature = "cumulus-primitives-aura")]
pub use cumulus_primitives_aura;

/// Cumulus related core primitive types and traits.
#[cfg(feature = "cumulus-primitives-core")]
pub use cumulus_primitives_core;

/// Inherent that needs to be present in every parachain block. Contains messages and a relay
/// chain storage-proof.
#[cfg(feature = "cumulus-primitives-parachain-inherent")]
pub use cumulus_primitives_parachain_inherent;

/// Hostfunction exposing storage proof size to the runtime.
#[cfg(feature = "cumulus-primitives-proof-size-hostfunction")]
pub use cumulus_primitives_proof_size_hostfunction;

/// Utilities to reclaim storage weight.
#[cfg(feature = "cumulus-primitives-storage-weight-reclaim")]
pub use cumulus_primitives_storage_weight_reclaim;

/// Provides timestamp related functionality for parachains.
#[cfg(feature = "cumulus-primitives-timestamp")]
pub use cumulus_primitives_timestamp;

/// Helper datatypes for Cumulus.
#[cfg(feature = "cumulus-primitives-utility")]
pub use cumulus_primitives_utility;

/// Implementation of the RelayChainInterface trait for Polkadot full-nodes.
#[cfg(feature = "cumulus-relay-chain-inprocess-interface")]
pub use cumulus_relay_chain_inprocess_interface;

/// Common interface for different relay chain datasources.
#[cfg(feature = "cumulus-relay-chain-interface")]
pub use cumulus_relay_chain_interface;

/// Minimal node implementation to be used in tandem with RPC or light-client mode.
#[cfg(feature = "cumulus-relay-chain-minimal-node")]
pub use cumulus_relay_chain_minimal_node;

/// Implementation of the RelayChainInterface trait that connects to a remote RPC-node.
#[cfg(feature = "cumulus-relay-chain-rpc-interface")]
pub use cumulus_relay_chain_rpc_interface;

/// Mocked relay state proof builder for testing Cumulus.
#[cfg(feature = "cumulus-test-relay-sproof-builder")]
pub use cumulus_test_relay_sproof_builder;

/// Common resources for integration testing with xcm-emulator.
#[cfg(feature = "emulated-integration-tests-common")]
pub use emulated_integration_tests_common;

/// Utility library for managing tree-like ordered data with logic for pruning the tree while
/// finalizing nodes.
#[cfg(feature = "fork-tree")]
pub use fork_tree;

/// Macro for benchmarking a FRAME runtime.
#[cfg(feature = "frame-benchmarking")]
pub use frame_benchmarking;

/// CLI for benchmarking FRAME.
#[cfg(feature = "frame-benchmarking-cli")]
pub use frame_benchmarking_cli;

/// Pallet for testing FRAME PoV benchmarking.
#[cfg(feature = "frame-benchmarking-pallet-pov")]
pub use frame_benchmarking_pallet_pov;

/// NPoS Solution Type.
#[cfg(feature = "frame-election-provider-solution-type")]
pub use frame_election_provider_solution_type;

/// election provider supporting traits.
#[cfg(feature = "frame-election-provider-support")]
pub use frame_election_provider_support;

/// FRAME executives engine.
#[cfg(feature = "frame-executive")]
pub use frame_executive;

/// FRAME signed extension for verifying the metadata hash.
#[cfg(feature = "frame-metadata-hash-extension")]
pub use frame_metadata_hash_extension;

/// An externalities provided environment that can load itself from remote nodes or cached
/// files.
#[cfg(feature = "frame-remote-externalities")]
pub use frame_remote_externalities;

/// Support code for the runtime.
#[cfg(feature = "frame-support")]
pub use frame_support;

/// Proc macro of Support code for the runtime.
#[cfg(feature = "frame-support-procedural")]
pub use frame_support_procedural;

/// Proc macro helpers for procedural macros.
#[cfg(feature = "frame-support-procedural-tools")]
pub use frame_support_procedural_tools;

/// Use to derive parsing for parsing struct.
#[cfg(feature = "frame-support-procedural-tools-derive")]
pub use frame_support_procedural_tools_derive;

/// FRAME system module.
#[cfg(feature = "frame-system")]
pub use frame_system;

/// FRAME System benchmarking.
#[cfg(feature = "frame-system-benchmarking")]
pub use frame_system_benchmarking;

/// Runtime API definition required by System RPC extensions.
#[cfg(feature = "frame-system-rpc-runtime-api")]
pub use frame_system_rpc_runtime_api;

/// Supporting types for try-runtime, testing and dry-running commands.
#[cfg(feature = "frame-try-runtime")]
pub use frame_try_runtime;

/// Bag threshold generation script for pallet-bag-list.
#[cfg(feature = "generate-bags")]
pub use generate_bags;

/// MMR Client gadget for substrate.
#[cfg(feature = "mmr-gadget")]
pub use mmr_gadget;

/// Node-specific RPC methods for interaction with Merkle Mountain Range pallet.
#[cfg(feature = "mmr-rpc")]
pub use mmr_rpc;

/// The Alliance pallet provides a collective for standard-setting industry collaboration.
#[cfg(feature = "pallet-alliance")]
pub use pallet_alliance;

/// FRAME asset conversion pallet.
#[cfg(feature = "pallet-asset-conversion")]
pub use pallet_asset_conversion;

/// FRAME asset conversion pallet's operations suite.
#[cfg(feature = "pallet-asset-conversion-ops")]
pub use pallet_asset_conversion_ops;

/// Pallet to manage transaction payments in assets by converting them to native assets.
#[cfg(feature = "pallet-asset-conversion-tx-payment")]
pub use pallet_asset_conversion_tx_payment;

/// Whitelist non-native assets for treasury spending and provide conversion to native balance.
#[cfg(feature = "pallet-asset-rate")]
pub use pallet_asset_rate;

/// pallet to manage transaction payments in assets.
#[cfg(feature = "pallet-asset-tx-payment")]
pub use pallet_asset_tx_payment;

/// FRAME asset management pallet.
#[cfg(feature = "pallet-assets")]
pub use pallet_assets;

/// Provides freezing features to `pallet-assets`.
#[cfg(feature = "pallet-assets-freezer")]
pub use pallet_assets_freezer;

/// FRAME atomic swap pallet.
#[cfg(feature = "pallet-atomic-swap")]
pub use pallet_atomic_swap;

/// FRAME AURA consensus pallet.
#[cfg(feature = "pallet-aura")]
pub use pallet_aura;

/// FRAME pallet for authority discovery.
#[cfg(feature = "pallet-authority-discovery")]
pub use pallet_authority_discovery;

/// Block and Uncle Author tracking for the FRAME.
#[cfg(feature = "pallet-authorship")]
pub use pallet_authorship;

/// Consensus extension module for BABE consensus. Collects on-chain randomness from VRF
/// outputs and manages epoch transitions.
#[cfg(feature = "pallet-babe")]
pub use pallet_babe;

/// FRAME pallet bags list.
#[cfg(feature = "pallet-bags-list")]
pub use pallet_bags_list;

/// FRAME pallet to manage balances.
#[cfg(feature = "pallet-balances")]
pub use pallet_balances;

/// BEEFY FRAME pallet.
#[cfg(feature = "pallet-beefy")]
pub use pallet_beefy;

/// BEEFY + MMR runtime utilities.
#[cfg(feature = "pallet-beefy-mmr")]
pub use pallet_beefy_mmr;

/// FRAME pallet to manage bounties.
#[cfg(feature = "pallet-bounties")]
pub use pallet_bounties;

/// Module implementing GRANDPA on-chain light client used for bridging consensus of
/// substrate-based chains.
#[cfg(feature = "pallet-bridge-grandpa")]
pub use pallet_bridge_grandpa;

/// Module that allows bridged chains to exchange messages using lane concept.
#[cfg(feature = "pallet-bridge-messages")]
pub use pallet_bridge_messages;

/// Module that allows bridged relay chains to exchange information on their parachains' heads.
#[cfg(feature = "pallet-bridge-parachains")]
pub use pallet_bridge_parachains;

/// Module used to store relayer rewards and coordinate relayers set.
#[cfg(feature = "pallet-bridge-relayers")]
pub use pallet_bridge_relayers;

/// Brokerage tool for managing Polkadot Core scheduling.
#[cfg(feature = "pallet-broker")]
pub use pallet_broker;

/// FRAME pallet to manage child bounties.
#[cfg(feature = "pallet-child-bounties")]
pub use pallet_child_bounties;

/// Simple pallet to select collators for a parachain.
#[cfg(feature = "pallet-collator-selection")]
pub use pallet_collator_selection;

/// Collective system: Members of a set of account IDs can make their collective feelings known
/// through dispatched calls from one of two specialized origins.
#[cfg(feature = "pallet-collective")]
pub use pallet_collective;

/// Managed content.
#[cfg(feature = "pallet-collective-content")]
pub use pallet_collective_content;

/// FRAME pallet for WASM contracts.
#[cfg(feature = "pallet-contracts")]
pub use pallet_contracts;

/// A mock network for testing pallet-contracts.
#[cfg(feature = "pallet-contracts-mock-network")]
pub use pallet_contracts_mock_network;

/// Procedural macros used in pallet_contracts.
#[cfg(feature = "pallet-contracts-proc-macro")]
pub use pallet_contracts_proc_macro;

/// Exposes all the host functions that a contract can import.
#[cfg(feature = "pallet-contracts-uapi")]
pub use pallet_contracts_uapi;

/// FRAME pallet for conviction voting in referenda.
#[cfg(feature = "pallet-conviction-voting")]
pub use pallet_conviction_voting;

/// Logic as per the description of The Fellowship for core Polkadot technology.
#[cfg(feature = "pallet-core-fellowship")]
pub use pallet_core_fellowship;

/// FRAME delegated staking pallet.
#[cfg(feature = "pallet-delegated-staking")]
pub use pallet_delegated_staking;

/// FRAME pallet for democracy.
#[cfg(feature = "pallet-democracy")]
pub use pallet_democracy;

/// FRAME example pallet.
#[cfg(feature = "pallet-dev-mode")]
pub use pallet_dev_mode;

/// PALLET two phase election providers.
#[cfg(feature = "pallet-election-provider-multi-phase")]
pub use pallet_election_provider_multi_phase;

/// Benchmarking for election provider support onchain config trait.
#[cfg(feature = "pallet-election-provider-support-benchmarking")]
pub use pallet_election_provider_support_benchmarking;

/// FRAME pallet based on seq-Phragmén election method.
#[cfg(feature = "pallet-elections-phragmen")]
pub use pallet_elections_phragmen;

/// FRAME fast unstake pallet.
#[cfg(feature = "pallet-fast-unstake")]
pub use pallet_fast_unstake;

/// FRAME pallet for pushing a chain to its weight limits.
#[cfg(feature = "pallet-glutton")]
pub use pallet_glutton;

/// FRAME pallet for GRANDPA finality gadget.
#[cfg(feature = "pallet-grandpa")]
pub use pallet_grandpa;

/// FRAME identity management pallet.
#[cfg(feature = "pallet-identity")]
pub use pallet_identity;

/// FRAME's I'm online pallet.
#[cfg(feature = "pallet-im-online")]
pub use pallet_im_online;

/// FRAME indices management pallet.
#[cfg(feature = "pallet-indices")]
pub use pallet_indices;

/// Insecure do not use in production: FRAME randomness collective flip pallet.
#[cfg(feature = "pallet-insecure-randomness-collective-flip")]
pub use pallet_insecure_randomness_collective_flip;

/// FRAME Participation Lottery Pallet.
#[cfg(feature = "pallet-lottery")]
pub use pallet_lottery;

/// FRAME membership management pallet.
#[cfg(feature = "pallet-membership")]
pub use pallet_membership;

/// FRAME pallet to queue and process messages.
#[cfg(feature = "pallet-message-queue")]
pub use pallet_message_queue;

/// FRAME pallet to execute multi-block migrations.
#[cfg(feature = "pallet-migrations")]
pub use pallet_migrations;

/// FRAME's mixnet pallet.
#[cfg(feature = "pallet-mixnet")]
pub use pallet_mixnet;

/// FRAME Merkle Mountain Range pallet.
#[cfg(feature = "pallet-mmr")]
pub use pallet_mmr;

/// FRAME multi-signature dispatch pallet.
#[cfg(feature = "pallet-multisig")]
pub use pallet_multisig;

/// FRAME pallet to convert non-fungible to fungible tokens.
#[cfg(feature = "pallet-nft-fractionalization")]
pub use pallet_nft_fractionalization;

/// FRAME NFTs pallet.
#[cfg(feature = "pallet-nfts")]
pub use pallet_nfts;

/// Runtime API for the FRAME NFTs pallet.
#[cfg(feature = "pallet-nfts-runtime-api")]
pub use pallet_nfts_runtime_api;

/// FRAME pallet for rewarding account freezing.
#[cfg(feature = "pallet-nis")]
pub use pallet_nis;

/// FRAME pallet for node authorization.
#[cfg(feature = "pallet-node-authorization")]
pub use pallet_node_authorization;

/// FRAME nomination pools pallet.
#[cfg(feature = "pallet-nomination-pools")]
pub use pallet_nomination_pools;

/// FRAME nomination pools pallet benchmarking.
#[cfg(feature = "pallet-nomination-pools-benchmarking")]
pub use pallet_nomination_pools_benchmarking;

/// Runtime API for nomination-pools FRAME pallet.
#[cfg(feature = "pallet-nomination-pools-runtime-api")]
pub use pallet_nomination_pools_runtime_api;

/// FRAME offences pallet.
#[cfg(feature = "pallet-offences")]
pub use pallet_offences;

/// FRAME offences pallet benchmarking.
#[cfg(feature = "pallet-offences-benchmarking")]
pub use pallet_offences_benchmarking;

/// FRAME pallet that provides a paged list data structure.
#[cfg(feature = "pallet-paged-list")]
pub use pallet_paged_list;

/// Pallet to store and configure parameters.
#[cfg(feature = "pallet-parameters")]
pub use pallet_parameters;

/// FRAME pallet for storing preimages of hashes.
#[cfg(feature = "pallet-preimage")]
pub use pallet_preimage;

/// FRAME proxying pallet.
#[cfg(feature = "pallet-proxy")]
pub use pallet_proxy;

/// Ranked collective system: Members of a set of account IDs can make their collective
/// feelings known through dispatched calls from one of two specialized origins.
#[cfg(feature = "pallet-ranked-collective")]
pub use pallet_ranked_collective;

/// FRAME account recovery pallet.
#[cfg(feature = "pallet-recovery")]
pub use pallet_recovery;

/// FRAME pallet for inclusive on-chain decisions.
#[cfg(feature = "pallet-referenda")]
pub use pallet_referenda;

/// Remark storage pallet.
#[cfg(feature = "pallet-remark")]
pub use pallet_remark;

/// FRAME pallet for PolkaVM contracts.
#[cfg(feature = "pallet-revive")]
pub use pallet_revive;

/// An Ethereum JSON-RPC server for pallet-revive.
#[cfg(feature = "pallet-revive-eth-rpc")]
pub use pallet_revive_eth_rpc;

/// A mock network for testing pallet-revive.
#[cfg(feature = "pallet-revive-mock-network")]
pub use pallet_revive_mock_network;

/// Procedural macros used in pallet_revive.
#[cfg(feature = "pallet-revive-proc-macro")]
pub use pallet_revive_proc_macro;

/// Exposes all the host functions that a contract can import.
#[cfg(feature = "pallet-revive-uapi")]
pub use pallet_revive_uapi;

/// FRAME root offences pallet.
#[cfg(feature = "pallet-root-offences")]
pub use pallet_root_offences;

/// FRAME root testing pallet.
#[cfg(feature = "pallet-root-testing")]
pub use pallet_root_testing;

/// FRAME safe-mode pallet.
#[cfg(feature = "pallet-safe-mode")]
pub use pallet_safe_mode;

/// Paymaster.
#[cfg(feature = "pallet-salary")]
pub use pallet_salary;

/// FRAME Scheduler pallet.
#[cfg(feature = "pallet-scheduler")]
pub use pallet_scheduler;

/// FRAME pallet for scored pools.
#[cfg(feature = "pallet-scored-pool")]
pub use pallet_scored_pool;

/// FRAME sessions pallet.
#[cfg(feature = "pallet-session")]
pub use pallet_session;

/// FRAME sessions pallet benchmarking.
#[cfg(feature = "pallet-session-benchmarking")]
pub use pallet_session_benchmarking;

/// Pallet to skip payments for calls annotated with `feeless_if` if the respective conditions
/// are satisfied.
#[cfg(feature = "pallet-skip-feeless-payment")]
pub use pallet_skip_feeless_payment;

/// FRAME society pallet.
#[cfg(feature = "pallet-society")]
pub use pallet_society;

/// FRAME pallet staking.
#[cfg(feature = "pallet-staking")]
pub use pallet_staking;

/// Reward Curve for FRAME staking pallet.
#[cfg(feature = "pallet-staking-reward-curve")]
pub use pallet_staking_reward_curve;

/// Reward function for FRAME staking pallet.
#[cfg(feature = "pallet-staking-reward-fn")]
pub use pallet_staking_reward_fn;

/// RPC runtime API for transaction payment FRAME pallet.
#[cfg(feature = "pallet-staking-runtime-api")]
pub use pallet_staking_runtime_api;

/// FRAME pallet migration of trie.
#[cfg(feature = "pallet-state-trie-migration")]
pub use pallet_state_trie_migration;

/// FRAME pallet for statement store.
#[cfg(feature = "pallet-statement")]
pub use pallet_statement;

/// FRAME pallet for sudo.
#[cfg(feature = "pallet-sudo")]
pub use pallet_sudo;

/// FRAME Timestamp Module.
#[cfg(feature = "pallet-timestamp")]
pub use pallet_timestamp;

/// FRAME pallet to manage tips.
#[cfg(feature = "pallet-tips")]
pub use pallet_tips;

/// FRAME pallet to manage transaction payments.
#[cfg(feature = "pallet-transaction-payment")]
pub use pallet_transaction_payment;

/// RPC interface for the transaction payment pallet.
#[cfg(feature = "pallet-transaction-payment-rpc")]
pub use pallet_transaction_payment_rpc;

/// RPC runtime API for transaction payment FRAME pallet.
#[cfg(feature = "pallet-transaction-payment-rpc-runtime-api")]
pub use pallet_transaction_payment_rpc_runtime_api;

/// Storage chain pallet.
#[cfg(feature = "pallet-transaction-storage")]
pub use pallet_transaction_storage;

/// FRAME pallet to manage treasury.
#[cfg(feature = "pallet-treasury")]
pub use pallet_treasury;

/// FRAME transaction pause pallet.
#[cfg(feature = "pallet-tx-pause")]
pub use pallet_tx_pause;

/// FRAME NFT asset management pallet.
#[cfg(feature = "pallet-uniques")]
pub use pallet_uniques;

/// FRAME utilities pallet.
#[cfg(feature = "pallet-utility")]
pub use pallet_utility;

/// FRAME verify signature pallet.
#[cfg(feature = "pallet-verify-signature")]
pub use pallet_verify_signature;

/// FRAME pallet for manage vesting.
#[cfg(feature = "pallet-vesting")]
pub use pallet_vesting;

/// FRAME pallet for whitelisting calls, and dispatching from a specific origin.
#[cfg(feature = "pallet-whitelist")]
pub use pallet_whitelist;

/// A pallet for handling XCM programs.
#[cfg(feature = "pallet-xcm")]
pub use pallet_xcm;

/// Benchmarks for the XCM pallet.
#[cfg(feature = "pallet-xcm-benchmarks")]
pub use pallet_xcm_benchmarks;

/// Module that adds dynamic bridges/lanes support to XCM infrastructure at the bridge hub.
#[cfg(feature = "pallet-xcm-bridge-hub")]
pub use pallet_xcm_bridge_hub;

/// Bridge hub interface for sibling/parent chains with dynamic fees support.
#[cfg(feature = "pallet-xcm-bridge-hub-router")]
pub use pallet_xcm_bridge_hub_router;

/// Logic which is common to all parachain runtimes.
#[cfg(feature = "parachains-common")]
pub use parachains_common;

/// Utils for Runtimes testing.
#[cfg(feature = "parachains-runtimes-test-utils")]
pub use parachains_runtimes_test_utils;

/// Polkadot Approval Distribution subsystem for the distribution of assignments and approvals
/// for approval checks on candidates over the network.
#[cfg(feature = "polkadot-approval-distribution")]
pub use polkadot_approval_distribution;

/// Polkadot Bitfiled Distribution subsystem, which gossips signed availability bitfields used
/// to compactly determine which backed candidates are available or not based on a 2/3+ quorum.
#[cfg(feature = "polkadot-availability-bitfield-distribution")]
pub use polkadot_availability_bitfield_distribution;

/// The Availability Distribution subsystem. Requests the required availability data. Also
/// distributes availability data and chunks to requesters.
#[cfg(feature = "polkadot-availability-distribution")]
pub use polkadot_availability_distribution;

/// The Availability Recovery subsystem. Handles requests for recovering the availability data
/// of included candidates.
#[cfg(feature = "polkadot-availability-recovery")]
pub use polkadot_availability_recovery;

/// Polkadot Relay-chain Client Node.
#[cfg(feature = "polkadot-cli")]
pub use polkadot_cli;

/// Polkadot Collator Protocol subsystem. Allows collators and validators to talk to each
/// other.
#[cfg(feature = "polkadot-collator-protocol")]
pub use polkadot_collator_protocol;

/// Core Polkadot types used by Relay Chains and parachains.
#[cfg(feature = "polkadot-core-primitives")]
pub use polkadot_core_primitives;

/// Polkadot Dispute Distribution subsystem, which ensures all concerned validators are aware
/// of a dispute and have the relevant votes.
#[cfg(feature = "polkadot-dispute-distribution")]
pub use polkadot_dispute_distribution;

/// Erasure coding used for Polkadot's availability system.
#[cfg(feature = "polkadot-erasure-coding")]
pub use polkadot_erasure_coding;

/// Polkadot Gossip Support subsystem. Responsible for keeping track of session changes and
/// issuing a connection request to the relevant validators on every new session.
#[cfg(feature = "polkadot-gossip-support")]
pub use polkadot_gossip_support;

/// The Network Bridge Subsystem — protocol multiplexer for Polkadot.
#[cfg(feature = "polkadot-network-bridge")]
pub use polkadot_network_bridge;

/// Collator-side subsystem that handles incoming candidate submissions from the parachain.
#[cfg(feature = "polkadot-node-collation-generation")]
pub use polkadot_node_collation_generation;

/// Approval Voting Subsystem of the Polkadot node.
#[cfg(feature = "polkadot-node-core-approval-voting")]
pub use polkadot_node_core_approval_voting;

/// Approval Voting Subsystem running approval work in parallel.
#[cfg(feature = "polkadot-node-core-approval-voting-parallel")]
pub use polkadot_node_core_approval_voting_parallel;

/// The Availability Store subsystem. Wrapper over the DB that stores availability data and
/// chunks.
#[cfg(feature = "polkadot-node-core-av-store")]
pub use polkadot_node_core_av_store;

/// The Candidate Backing Subsystem. Tracks parachain candidates that can be backed, as well as
/// the issuance of statements about candidates.
#[cfg(feature = "polkadot-node-core-backing")]
pub use polkadot_node_core_backing;

/// Bitfield signing subsystem for the Polkadot node.
#[cfg(feature = "polkadot-node-core-bitfield-signing")]
pub use polkadot_node_core_bitfield_signing;

/// Polkadot crate that implements the Candidate Validation subsystem. Handles requests to
/// validate candidates according to a PVF.
#[cfg(feature = "polkadot-node-core-candidate-validation")]
pub use polkadot_node_core_candidate_validation;

/// The Chain API subsystem provides access to chain related utility functions like block
/// number to hash conversions.
#[cfg(feature = "polkadot-node-core-chain-api")]
pub use polkadot_node_core_chain_api;

/// Chain Selection Subsystem.
#[cfg(feature = "polkadot-node-core-chain-selection")]
pub use polkadot_node_core_chain_selection;

/// The node-side components that participate in disputes.
#[cfg(feature = "polkadot-node-core-dispute-coordinator")]
pub use polkadot_node_core_dispute_coordinator;

/// Parachains inherent data provider for Polkadot node.
#[cfg(feature = "polkadot-node-core-parachains-inherent")]
pub use polkadot_node_core_parachains_inherent;

/// The Prospective Parachains subsystem. Tracks and handles prospective parachain fragments.
#[cfg(feature = "polkadot-node-core-prospective-parachains")]
pub use polkadot_node_core_prospective_parachains;

/// Responsible for assembling a relay chain block from a set of available parachain
/// candidates.
#[cfg(feature = "polkadot-node-core-provisioner")]
pub use polkadot_node_core_provisioner;

/// Polkadot crate that implements the PVF validation host. Responsible for coordinating
/// preparation and execution of PVFs.
#[cfg(feature = "polkadot-node-core-pvf")]
pub use polkadot_node_core_pvf;

/// Polkadot crate that implements the PVF pre-checking subsystem. Responsible for checking and
/// voting for PVFs that are pending approval.
#[cfg(feature = "polkadot-node-core-pvf-checker")]
pub use polkadot_node_core_pvf_checker;

/// Polkadot crate that contains functionality related to PVFs that is shared by the PVF host
/// and the PVF workers.
#[cfg(feature = "polkadot-node-core-pvf-common")]
pub use polkadot_node_core_pvf_common;

/// Polkadot crate that contains the logic for executing PVFs. Used by the
/// polkadot-execute-worker binary.
#[cfg(feature = "polkadot-node-core-pvf-execute-worker")]
pub use polkadot_node_core_pvf_execute_worker;

/// Polkadot crate that contains the logic for preparing PVFs. Used by the
/// polkadot-prepare-worker binary.
#[cfg(feature = "polkadot-node-core-pvf-prepare-worker")]
pub use polkadot_node_core_pvf_prepare_worker;

/// Wrapper around the parachain-related runtime APIs.
#[cfg(feature = "polkadot-node-core-runtime-api")]
pub use polkadot_node_core_runtime_api;

/// Subsystem metric helpers.
#[cfg(feature = "polkadot-node-metrics")]
pub use polkadot_node_metrics;

/// Primitives types for the Node-side.
#[cfg(feature = "polkadot-node-network-protocol")]
pub use polkadot_node_network_protocol;

/// Primitives types for the Node-side.
#[cfg(feature = "polkadot-node-primitives")]
pub use polkadot_node_primitives;

/// Subsystem traits and message definitions and the generated overseer.
#[cfg(feature = "polkadot-node-subsystem")]
pub use polkadot_node_subsystem;

/// Subsystem traits and message definitions.
#[cfg(feature = "polkadot-node-subsystem-types")]
pub use polkadot_node_subsystem_types;

/// Subsystem traits and message definitions.
#[cfg(feature = "polkadot-node-subsystem-util")]
pub use polkadot_node_subsystem_util;

/// Helper library that can be used to build a parachain node.
#[cfg(feature = "polkadot-omni-node-lib")]
pub use polkadot_omni_node_lib;

/// System overseer of the Polkadot node.
#[cfg(feature = "polkadot-overseer")]
pub use polkadot_overseer;

/// Types and utilities for creating and working with parachains.
#[cfg(feature = "polkadot-parachain-primitives")]
pub use polkadot_parachain_primitives;

/// Shared primitives used by Polkadot runtime.
#[cfg(feature = "polkadot-primitives")]
pub use polkadot_primitives;

/// Polkadot specific RPC functionality.
#[cfg(feature = "polkadot-rpc")]
pub use polkadot_rpc;

/// Pallets and constants used in Relay Chain networks.
#[cfg(feature = "polkadot-runtime-common")]
pub use polkadot_runtime_common;

/// Runtime metric interface for the Polkadot node.
#[cfg(feature = "polkadot-runtime-metrics")]
pub use polkadot_runtime_metrics;

/// Relay Chain runtime code responsible for Parachains.
#[cfg(feature = "polkadot-runtime-parachains")]
pub use polkadot_runtime_parachains;

/// Experimental: The single package to get you started with building frame pallets and
/// runtimes.
#[cfg(feature = "polkadot-sdk-frame")]
pub use polkadot_sdk_frame;

/// Utils to tie different Polkadot components together and allow instantiation of a node.
#[cfg(feature = "polkadot-service")]
pub use polkadot_service;

/// Statement Distribution Subsystem.
#[cfg(feature = "polkadot-statement-distribution")]
pub use polkadot_statement_distribution;

/// Stores messages other authorities issue about candidates in Polkadot.
#[cfg(feature = "polkadot-statement-table")]
pub use polkadot_statement_table;

/// Collection of allocator implementations.
#[cfg(feature = "sc-allocator")]
pub use sc_allocator;

/// Substrate authority discovery.
#[cfg(feature = "sc-authority-discovery")]
pub use sc_authority_discovery;

/// Basic implementation of block-authoring logic.
#[cfg(feature = "sc-basic-authorship")]
pub use sc_basic_authorship;

/// Substrate block builder.
#[cfg(feature = "sc-block-builder")]
pub use sc_block_builder;

/// Substrate chain configurations.
#[cfg(feature = "sc-chain-spec")]
pub use sc_chain_spec;

/// Macros to derive chain spec extension traits implementation.
#[cfg(feature = "sc-chain-spec-derive")]
pub use sc_chain_spec_derive;

/// Substrate CLI interface.
#[cfg(feature = "sc-cli")]
pub use sc_cli;

/// Substrate client interfaces.
#[cfg(feature = "sc-client-api")]
pub use sc_client_api;

/// Client backend that uses RocksDB database as storage.
#[cfg(feature = "sc-client-db")]
pub use sc_client_db;

/// Collection of common consensus specific implementations for Substrate (client).
#[cfg(feature = "sc-consensus")]
pub use sc_consensus;

/// Aura consensus algorithm for substrate.
#[cfg(feature = "sc-consensus-aura")]
pub use sc_consensus_aura;

/// BABE consensus algorithm for substrate.
#[cfg(feature = "sc-consensus-babe")]
pub use sc_consensus_babe;

/// RPC extensions for the BABE consensus algorithm.
#[cfg(feature = "sc-consensus-babe-rpc")]
pub use sc_consensus_babe_rpc;

/// BEEFY Client gadget for substrate.
#[cfg(feature = "sc-consensus-beefy")]
pub use sc_consensus_beefy;

/// RPC for the BEEFY Client gadget for substrate.
#[cfg(feature = "sc-consensus-beefy-rpc")]
pub use sc_consensus_beefy_rpc;

/// Generic epochs-based utilities for consensus.
#[cfg(feature = "sc-consensus-epochs")]
pub use sc_consensus_epochs;

/// Integration of the GRANDPA finality gadget into substrate.
#[cfg(feature = "sc-consensus-grandpa")]
pub use sc_consensus_grandpa;

/// RPC extensions for the GRANDPA finality gadget.
#[cfg(feature = "sc-consensus-grandpa-rpc")]
pub use sc_consensus_grandpa_rpc;

/// Manual sealing engine for Substrate.
#[cfg(feature = "sc-consensus-manual-seal")]
pub use sc_consensus_manual_seal;

/// PoW consensus algorithm for substrate.
#[cfg(feature = "sc-consensus-pow")]
pub use sc_consensus_pow;

/// Generic slots-based utilities for consensus.
#[cfg(feature = "sc-consensus-slots")]
pub use sc_consensus_slots;

/// A crate that provides means of executing/dispatching calls into the runtime.
#[cfg(feature = "sc-executor")]
pub use sc_executor;

/// A set of common definitions that are needed for defining execution engines.
#[cfg(feature = "sc-executor-common")]
pub use sc_executor_common;

/// PolkaVM executor for Substrate.
#[cfg(feature = "sc-executor-polkavm")]
pub use sc_executor_polkavm;

/// Defines a `WasmRuntime` that uses the Wasmtime JIT to execute.
#[cfg(feature = "sc-executor-wasmtime")]
pub use sc_executor_wasmtime;

/// Substrate informant.
#[cfg(feature = "sc-informant")]
pub use sc_informant;

/// Keystore (and session key management) for ed25519 based chains like Polkadot.
#[cfg(feature = "sc-keystore")]
pub use sc_keystore;

/// Substrate mixnet service.
#[cfg(feature = "sc-mixnet")]
pub use sc_mixnet;

/// Substrate network protocol.
#[cfg(feature = "sc-network")]
pub use sc_network;

/// Substrate network common.
#[cfg(feature = "sc-network-common")]
pub use sc_network_common;

/// Gossiping for the Substrate network protocol.
#[cfg(feature = "sc-network-gossip")]
pub use sc_network_gossip;

/// Substrate light network protocol.
#[cfg(feature = "sc-network-light")]
pub use sc_network_light;

/// Substrate statement protocol.
#[cfg(feature = "sc-network-statement")]
pub use sc_network_statement;

/// Substrate sync network protocol.
#[cfg(feature = "sc-network-sync")]
pub use sc_network_sync;

/// Substrate transaction protocol.
#[cfg(feature = "sc-network-transactions")]
pub use sc_network_transactions;

/// Substrate network types.
#[cfg(feature = "sc-network-types")]
pub use sc_network_types;

/// Substrate offchain workers.
#[cfg(feature = "sc-offchain")]
pub use sc_offchain;

/// Basic metrics for block production.
#[cfg(feature = "sc-proposer-metrics")]
pub use sc_proposer_metrics;

/// Substrate Client RPC.
#[cfg(feature = "sc-rpc")]
pub use sc_rpc;

/// Substrate RPC interfaces.
#[cfg(feature = "sc-rpc-api")]
pub use sc_rpc_api;

/// Substrate RPC servers.
#[cfg(feature = "sc-rpc-server")]
pub use sc_rpc_server;

/// Substrate RPC interface v2.
#[cfg(feature = "sc-rpc-spec-v2")]
pub use sc_rpc_spec_v2;

/// Substrate client utilities for frame runtime functions calls.
#[cfg(feature = "sc-runtime-utilities")]
pub use sc_runtime_utilities;

/// Substrate service. Starts a thread that spins up the network, client, and extrinsic pool.
/// Manages communication between them.
#[cfg(feature = "sc-service")]
pub use sc_service;

/// State database maintenance. Handles canonicalization and pruning in the database.
#[cfg(feature = "sc-state-db")]
pub use sc_state_db;

/// Substrate statement store.
#[cfg(feature = "sc-statement-store")]
pub use sc_statement_store;

/// Storage monitor service for substrate.
#[cfg(feature = "sc-storage-monitor")]
pub use sc_storage_monitor;

/// A RPC handler to create sync states for light clients.
#[cfg(feature = "sc-sync-state-rpc")]
pub use sc_sync_state_rpc;

/// A crate that provides basic hardware and software telemetry information.
#[cfg(feature = "sc-sysinfo")]
pub use sc_sysinfo;

/// Telemetry utils.
#[cfg(feature = "sc-telemetry")]
pub use sc_telemetry;

/// Instrumentation implementation for substrate.
#[cfg(feature = "sc-tracing")]
pub use sc_tracing;

/// Helper macros for Substrate's client CLI.
#[cfg(feature = "sc-tracing-proc-macro")]
pub use sc_tracing_proc_macro;

/// Substrate transaction pool implementation.
#[cfg(feature = "sc-transaction-pool")]
pub use sc_transaction_pool;

/// Transaction pool client facing API.
#[cfg(feature = "sc-transaction-pool-api")]
pub use sc_transaction_pool_api;

/// I/O for Substrate runtimes.
#[cfg(feature = "sc-utils")]
pub use sc_utils;

/// Helper crate for generating slot ranges for the Polkadot runtime.
#[cfg(feature = "slot-range-helper")]
pub use slot_range_helper;

/// Snowbridge Beacon Primitives.
#[cfg(feature = "snowbridge-beacon-primitives")]
pub use snowbridge_beacon_primitives;

/// Snowbridge Core.
#[cfg(feature = "snowbridge-core")]
pub use snowbridge_core;

/// Snowbridge Ethereum.
#[cfg(feature = "snowbridge-ethereum")]
pub use snowbridge_ethereum;

/// Snowbridge Outbound Queue Merkle Tree.
#[cfg(feature = "snowbridge-outbound-queue-merkle-tree")]
pub use snowbridge_outbound_queue_merkle_tree;

/// Snowbridge Outbound Queue Runtime API.
#[cfg(feature = "snowbridge-outbound-queue-runtime-api")]
pub use snowbridge_outbound_queue_runtime_api;

/// Snowbridge Ethereum Client Pallet.
#[cfg(feature = "snowbridge-pallet-ethereum-client")]
pub use snowbridge_pallet_ethereum_client;

/// Snowbridge Ethereum Client Test Fixtures.
#[cfg(feature = "snowbridge-pallet-ethereum-client-fixtures")]
pub use snowbridge_pallet_ethereum_client_fixtures;

/// Snowbridge Inbound Queue Pallet.
#[cfg(feature = "snowbridge-pallet-inbound-queue")]
pub use snowbridge_pallet_inbound_queue;

/// Snowbridge Inbound Queue Test Fixtures.
#[cfg(feature = "snowbridge-pallet-inbound-queue-fixtures")]
pub use snowbridge_pallet_inbound_queue_fixtures;

/// Snowbridge Outbound Queue Pallet.
#[cfg(feature = "snowbridge-pallet-outbound-queue")]
pub use snowbridge_pallet_outbound_queue;

/// Snowbridge System Pallet.
#[cfg(feature = "snowbridge-pallet-system")]
pub use snowbridge_pallet_system;

/// Snowbridge Router Primitives.
#[cfg(feature = "snowbridge-router-primitives")]
pub use snowbridge_router_primitives;

/// Snowbridge Runtime Common.
#[cfg(feature = "snowbridge-runtime-common")]
pub use snowbridge_runtime_common;

/// Snowbridge Runtime Tests.
#[cfg(feature = "snowbridge-runtime-test-common")]
pub use snowbridge_runtime_test_common;

/// Snowbridge System Runtime API.
#[cfg(feature = "snowbridge-system-runtime-api")]
pub use snowbridge_system_runtime_api;

/// Substrate runtime api primitives.
#[cfg(feature = "sp-api")]
pub use sp_api;

/// Macros for declaring and implementing runtime apis.
#[cfg(feature = "sp-api-proc-macro")]
pub use sp_api_proc_macro;

/// Provides facilities for generating application specific crypto wrapper types.
#[cfg(feature = "sp-application-crypto")]
pub use sp_application_crypto;

/// Minimal fixed point arithmetic primitives and types for runtime.
#[cfg(feature = "sp-arithmetic")]
pub use sp_arithmetic;

/// Authority discovery primitives.
#[cfg(feature = "sp-authority-discovery")]
pub use sp_authority_discovery;

/// The block builder runtime api.
#[cfg(feature = "sp-block-builder")]
pub use sp_block_builder;

/// Substrate blockchain traits and primitives.
#[cfg(feature = "sp-blockchain")]
pub use sp_blockchain;

/// Common utilities for building and using consensus engines in substrate.
#[cfg(feature = "sp-consensus")]
pub use sp_consensus;

/// Primitives for Aura consensus.
#[cfg(feature = "sp-consensus-aura")]
pub use sp_consensus_aura;

/// Primitives for BABE consensus.
#[cfg(feature = "sp-consensus-babe")]
pub use sp_consensus_babe;

/// Primitives for BEEFY protocol.
#[cfg(feature = "sp-consensus-beefy")]
pub use sp_consensus_beefy;

/// Primitives for GRANDPA integration, suitable for WASM compilation.
#[cfg(feature = "sp-consensus-grandpa")]
pub use sp_consensus_grandpa;

/// Primitives for Aura consensus.
#[cfg(feature = "sp-consensus-pow")]
pub use sp_consensus_pow;

/// Primitives for slots-based consensus.
#[cfg(feature = "sp-consensus-slots")]
pub use sp_consensus_slots;

/// Shareable Substrate types.
#[cfg(feature = "sp-core")]
pub use sp_core;

/// Hashing primitives (deprecated: use sp-crypto-hashing for new applications).
#[cfg(feature = "sp-core-hashing")]
pub use sp_core_hashing;

/// Procedural macros for calculating static hashes (deprecated in favor of
/// `sp-crypto-hashing-proc-macro`).
#[cfg(feature = "sp-core-hashing-proc-macro")]
pub use sp_core_hashing_proc_macro;

/// Host functions for common Arkworks elliptic curve operations.
#[cfg(feature = "sp-crypto-ec-utils")]
pub use sp_crypto_ec_utils;

/// Hashing primitives.
#[cfg(feature = "sp-crypto-hashing")]
pub use sp_crypto_hashing;

/// Procedural macros for calculating static hashes.
#[cfg(feature = "sp-crypto-hashing-proc-macro")]
pub use sp_crypto_hashing_proc_macro;

/// Substrate database trait.
#[cfg(feature = "sp-database")]
pub use sp_database;

/// Macros to derive runtime debug implementation.
#[cfg(feature = "sp-debug-derive")]
pub use sp_debug_derive;

/// Substrate externalities abstraction.
#[cfg(feature = "sp-externalities")]
pub use sp_externalities;

/// Substrate RuntimeGenesisConfig builder API.
#[cfg(feature = "sp-genesis-builder")]
pub use sp_genesis_builder;

/// Provides types and traits for creating and checking inherents.
#[cfg(feature = "sp-inherents")]
pub use sp_inherents;

/// I/O for Substrate runtimes.
#[cfg(feature = "sp-io")]
pub use sp_io;

/// Keyring support code for the runtime. A set of test accounts.
#[cfg(feature = "sp-keyring")]
pub use sp_keyring;

/// Keystore primitives.
#[cfg(feature = "sp-keystore")]
pub use sp_keystore;

/// Handling of blobs, usually Wasm code, which may be compressed.
#[cfg(feature = "sp-maybe-compressed-blob")]
pub use sp_maybe_compressed_blob;

/// Intermediate representation of the runtime metadata.
#[cfg(feature = "sp-metadata-ir")]
pub use sp_metadata_ir;

/// Substrate mixnet types and runtime interface.
#[cfg(feature = "sp-mixnet")]
pub use sp_mixnet;

/// Merkle Mountain Range primitives.
#[cfg(feature = "sp-mmr-primitives")]
pub use sp_mmr_primitives;

/// NPoS election algorithm primitives.
#[cfg(feature = "sp-npos-elections")]
pub use sp_npos_elections;

/// Substrate offchain workers primitives.
#[cfg(feature = "sp-offchain")]
pub use sp_offchain;

/// Custom panic hook with bug report link.
#[cfg(feature = "sp-panic-handler")]
pub use sp_panic_handler;

/// Substrate RPC primitives and utilities.
#[cfg(feature = "sp-rpc")]
pub use sp_rpc;

/// Runtime Modules shared primitive types.
#[cfg(feature = "sp-runtime")]
pub use sp_runtime;

/// Substrate runtime interface.
#[cfg(feature = "sp-runtime-interface")]
pub use sp_runtime_interface;

/// This crate provides procedural macros for usage within the context of the Substrate runtime
/// interface.
#[cfg(feature = "sp-runtime-interface-proc-macro")]
pub use sp_runtime_interface_proc_macro;

/// Primitives for sessions.
#[cfg(feature = "sp-session")]
pub use sp_session;

/// A crate which contains primitives that are useful for implementation that uses staking
/// approaches in general. Definitions related to sessions, slashing, etc go here.
#[cfg(feature = "sp-staking")]
pub use sp_staking;

/// Substrate State Machine.
#[cfg(feature = "sp-state-machine")]
pub use sp_state_machine;

/// A crate which contains primitives related to the statement store.
#[cfg(feature = "sp-statement-store")]
pub use sp_statement_store;

/// Lowest-abstraction level for the Substrate runtime: just exports useful primitives from std
/// or client/alloc to be used with any code that depends on the runtime.
#[cfg(feature = "sp-std")]
pub use sp_std;

/// Storage related primitives.
#[cfg(feature = "sp-storage")]
pub use sp_storage;

/// Substrate core types and inherents for timestamps.
#[cfg(feature = "sp-timestamp")]
pub use sp_timestamp;

/// Instrumentation primitives and macros for Substrate.
#[cfg(feature = "sp-tracing")]
pub use sp_tracing;

/// Transaction pool runtime facing API.
#[cfg(feature = "sp-transaction-pool")]
pub use sp_transaction_pool;

/// Transaction storage proof primitives.
#[cfg(feature = "sp-transaction-storage-proof")]
pub use sp_transaction_storage_proof;

/// Patricia trie stuff using a parity-scale-codec node format.
#[cfg(feature = "sp-trie")]
pub use sp_trie;

/// Version module for the Substrate runtime; Provides a function that returns the runtime
/// version.
#[cfg(feature = "sp-version")]
pub use sp_version;

/// Macro for defining a runtime version.
#[cfg(feature = "sp-version-proc-macro")]
pub use sp_version_proc_macro;

/// Types and traits for interfacing between the host and the wasm runtime.
#[cfg(feature = "sp-wasm-interface")]
pub use sp_wasm_interface;

/// Types and traits for interfacing between the host and the wasm runtime.
#[cfg(feature = "sp-weights")]
pub use sp_weights;

/// Utility for building chain-specification files for Substrate-based runtimes based on
/// `sp-genesis-builder`.
#[cfg(feature = "staging-chain-spec-builder")]
pub use staging_chain_spec_builder;

/// Substrate node block inspection tool.
#[cfg(feature = "staging-node-inspect")]
pub use staging_node_inspect;

/// Pallet to store the parachain ID.
#[cfg(feature = "staging-parachain-info")]
pub use staging_parachain_info;

/// Tracking allocator to control the amount of memory consumed by the process.
#[cfg(feature = "staging-tracking-allocator")]
pub use staging_tracking_allocator;

/// The basic XCM datastructures.
#[cfg(feature = "staging-xcm")]
pub use staging_xcm;

/// Tools & types for building with XCM and its executor.
#[cfg(feature = "staging-xcm-builder")]
pub use staging_xcm_builder;

/// An abstract and configurable XCM message executor.
#[cfg(feature = "staging-xcm-executor")]
pub use staging_xcm_executor;

/// Generate and restore keys for Substrate based chains such as Polkadot, Kusama and a growing
/// number of parachains and Substrate based projects.
#[cfg(feature = "subkey")]
pub use subkey;

/// Converting BIP39 entropy to valid Substrate (sr25519) SecretKeys.
#[cfg(feature = "substrate-bip39")]
pub use substrate_bip39;

/// Crate with utility functions for `build.rs` scripts.
#[cfg(feature = "substrate-build-script-utils")]
pub use substrate_build_script_utils;

/// Substrate RPC for FRAME's support.
#[cfg(feature = "substrate-frame-rpc-support")]
pub use substrate_frame_rpc_support;

/// FRAME's system exposed over Substrate RPC.
#[cfg(feature = "substrate-frame-rpc-system")]
pub use substrate_frame_rpc_system;

/// Endpoint to expose Prometheus metrics.
#[cfg(feature = "substrate-prometheus-endpoint")]
pub use substrate_prometheus_endpoint;

/// Shared JSON-RPC client.
#[cfg(feature = "substrate-rpc-client")]
pub use substrate_rpc_client;

/// Node-specific RPC methods for interaction with state trie migration.
#[cfg(feature = "substrate-state-trie-migration-rpc")]
pub use substrate_state_trie_migration_rpc;

/// Utility for building WASM binaries.
#[cfg(feature = "substrate-wasm-builder")]
pub use substrate_wasm_builder;

/// Common constants for Testnet Parachains runtimes.
#[cfg(feature = "testnet-parachains-constants")]
pub use testnet_parachains_constants;

/// Stick logs together with the TraceID as provided by tempo.
#[cfg(feature = "tracing-gum")]
pub use tracing_gum;

/// Generate an overseer including builder pattern and message wrapper from a single annotated
/// struct definition.
#[cfg(feature = "tracing-gum-proc-macro")]
pub use tracing_gum_proc_macro;

/// Test kit to emulate XCM program execution.
#[cfg(feature = "xcm-emulator")]
pub use xcm_emulator;

/// Procedural macros for XCM.
#[cfg(feature = "xcm-procedural")]
pub use xcm_procedural;

/// XCM runtime APIs.
#[cfg(feature = "xcm-runtime-apis")]
pub use xcm_runtime_apis;

/// Test kit to simulate cross-chain message passing and XCM execution.
#[cfg(feature = "xcm-simulator")]
pub use xcm_simulator;