@pezkuwi/api-derive 16.5.5

package/build/democracy/util.d.ts

@@ -0,0 +1,18 @@
+import type { Hash, ReferendumInfoTo239 } from '@pezkuwi/types/interfaces';
+import type { FrameSupportPreimagesBounded, PalletDemocracyReferendumInfo, PalletDemocracyReferendumStatus, PalletDemocracyVoteThreshold } from '@pezkuwi/types/lookup';
+import type { Option } from '@pezkuwi/types-codec';
+import type { HexString } from '@pezkuwi/util/types';
+import type { DeriveReferendum, DeriveReferendumVote, DeriveReferendumVotes } from '../types.js';
+import { BN } from '@pezkuwi/util';
+interface ApproxState {
+    votedAye: BN;
+    votedNay: BN;
+    votedTotal: BN;
+}
+export declare function compareRationals(n1: BN, d1: BN, n2: BN, d2: BN): boolean;
+export declare function calcPassing(threshold: PalletDemocracyVoteThreshold, sqrtElectorate: BN, state: ApproxState): boolean;
+export declare function calcVotes(sqrtElectorate: BN, referendum: DeriveReferendum, votes: DeriveReferendumVote[]): DeriveReferendumVotes;
+export declare function getStatus(info: Option<PalletDemocracyReferendumInfo | ReferendumInfoTo239>): PalletDemocracyReferendumStatus | ReferendumInfoTo239 | null;
+export declare function getImageHashBounded(hash: Uint8Array | string | Hash | FrameSupportPreimagesBounded): HexString;
+export declare function getImageHash(status: PalletDemocracyReferendumStatus | ReferendumInfoTo239): HexString;
+export {};

package/build/derive.d.ts

@@ -0,0 +1,52 @@
+import type { AnyFunction } from '@pezkuwi/types/types';
+import * as accounts from './accounts/index.js';
+import * as alliance from './alliance/index.js';
+import * as bagsList from './bagsList/index.js';
+import * as balances from './balances/index.js';
+import * as bounties from './bounties/index.js';
+import * as chain from './chain/index.js';
+import * as contracts from './contracts/index.js';
+import * as council from './council/index.js';
+import * as crowdloan from './crowdloan/index.js';
+import * as democracy from './democracy/index.js';
+import * as elections from './elections/index.js';
+import * as imOnline from './imOnline/index.js';
+import * as membership from './membership/index.js';
+import * as parachains from './parachains/index.js';
+import * as session from './session/index.js';
+import * as society from './society/index.js';
+import * as staking from './staking/index.js';
+import * as technicalCommittee from './technicalCommittee/index.js';
+import * as treasury from './treasury/index.js';
+import * as tx from './tx/index.js';
+export declare const derive: {
+    accounts: typeof accounts;
+    alliance: typeof alliance;
+    bagsList: typeof bagsList;
+    balances: typeof balances;
+    bounties: typeof bounties;
+    chain: typeof chain;
+    contracts: typeof contracts;
+    council: typeof council;
+    crowdloan: typeof crowdloan;
+    democracy: typeof democracy;
+    elections: typeof elections;
+    imOnline: typeof imOnline;
+    membership: typeof membership;
+    parachains: typeof parachains;
+    session: typeof session;
+    society: typeof society;
+    staking: typeof staking;
+    technicalCommittee: typeof technicalCommittee;
+    treasury: typeof treasury;
+    tx: typeof tx;
+};
+type DeriveSection<Section> = {
+    [M in keyof Section]: Section[M] extends AnyFunction ? ReturnType<Section[M]> : never;
+};
+type DeriveAllSections<AllSections> = {
+    [S in keyof AllSections]: DeriveSection<AllSections[S]>;
+};
+export interface ExactDerive extends DeriveAllSections<typeof derive> {
+}
+export {};

package/build/elections/index.d.ts

@@ -0,0 +1 @@
+export * from './info.js';

package/build/elections/info.d.ts

@@ -0,0 +1,14 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi } from '../types.js';
+import type { DeriveElectionsInfo } from './types.js';
+/**
+ * @name info
+ * @description An object containing the combined results of the storage queries for all relevant election module properties.
+ * @example
+ * ```javascript
+ * api.derive.elections.info(({ members, candidates }) => {
+ *   console.log(`There are currently ${members.length} council members and ${candidates.length} prospective council candidates.`);
+ * });
+ * ```
+ */
+export declare function info(instanceId: string, api: DeriveApi): () => Observable<DeriveElectionsInfo>;

package/build/elections/types.d.ts

@@ -0,0 +1,18 @@
+import type { u32 } from '@pezkuwi/types';
+import type { AccountId, Balance, BlockNumber, SetIndex, VoteIndex } from '@pezkuwi/types/interfaces';
+export interface DeriveElectionsInfo {
+    candidates: AccountId[];
+    candidateCount: u32;
+    candidacyBond?: Balance;
+    desiredRunnersUp?: u32;
+    desiredSeats?: u32;
+    members: [AccountId, Balance][];
+    nextVoterSet?: SetIndex;
+    runnersUp: [AccountId, Balance][];
+    termDuration?: BlockNumber;
+    voteCount?: VoteIndex;
+    voterCount?: SetIndex;
+    votingBond?: Balance;
+    votingBondBase?: Balance;
+    votingBondFactor?: Balance;
+}

package/build/imOnline/index.d.ts

@@ -0,0 +1 @@
+export * from './receivedHeartbeats.js';

package/build/imOnline/receivedHeartbeats.d.ts

@@ -0,0 +1,13 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveHeartbeats } from '../types.js';
+/**
+ * @name receivedHeartbeats
+ * @description Return a boolean array indicating whether the passed accounts had received heartbeats in the current session.
+ * @example
+ * ```javascript
+ * let unsub = await api.derive.imOnline.receivedHeartbeats((heartbeat) => {
+ *   console.log(heartbeat);
+ * });
+ * ```
+ */
+export declare function receivedHeartbeats(instanceId: string, api: DeriveApi): () => Observable<DeriveHeartbeats>;

package/build/index.d.ts

@@ -0,0 +1,2 @@
+import './packageDetect.js';
+export * from './bundle.js';

package/build/membership/index.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @name members
+ * @description Retrieves the list of members in the "membership" collective.
+ * @example
+ * ```javascript
+ * const members = await api.derive.membership.members();
+ * console.log(`Members: ${JSON.stringify(members)});
+ * ```
+ */
+export declare const members: import("../collective/types.js").MembersFnRet;
+/**
+ * @name hasProposals
+ * @description Checks if there are any active proposals in the "membership" collective.
+ * @example
+ * ```javascript
+ * const exists = await api.derive.membership.hasProposals();
+ * console.log(exists);
+ * ```
+ */
+export declare const hasProposals: import("../collective/types.js").HasProposalsFnRet;
+/**
+ * @name proposal
+ * @description Retrieves details of a specific proposal in the "membership" collective by its hash.
+ * @example
+ * ```javascript
+ * const proposalDetails = await api.derive.membership.proposal(PROPOSAL_HASH);
+ * console.log(proposalDetails);
+ * ```
+ */
+export declare const proposal: import("../collective/types.js").ProposalFnRet;
+/**
+ * @name proposalCount
+ * @description Retrieves the total number of proposals in the "membership" collective.
+ * @example
+ * ```javascript
+ * const count = await api.derive.membership.proposalCount();
+ * console.log(`Amount of proposals: ${count}`);
+ * ```
+ */
+export declare const proposalCount: import("../collective/types.js").ProposalCountFnRet;
+/**
+ * @name proposalHashes
+ * @description Retrieves an array of hashes for all active proposals in the "membership" collective.
+ * @example
+ * ```javascript
+ * const hashes = await api.derive.membership.proposalHashes();
+ * console.log(`Proposals ${JSON.stringify(hashes)}`);
+ * ```
+ */
+export declare const proposalHashes: import("../collective/types.js").ProposalHashesFnRet;
+/**
+ * @name proposals
+ * @description Retrieves a list of all active proposals in the "membership" collective.
+ * @example
+ * ```javascript
+ * const proposals = await api.derive.membership.proposals();
+ * console.log(proposals);
+ * ```
+ */
+export declare const proposals: import("../collective/types.js").ProposalsFnRet;
+/**
+ * @name prime
+ * @description Retrieves the prime member of the "membership" collective, if one exists.
+ * @example
+ * ```javascript
+ * const primeMember = await api.derive.membership.prime();
+ * console.log(primeMember);
+ * ```
+ */
+export declare const prime: import("../collective/types.js").PrimeFnRet;

package/build/packageDetect.d.ts

@@ -0,0 +1 @@
+export {};

package/build/packageInfo.d.ts

@@ -0,0 +1,6 @@
+export declare const packageInfo: {
+    name: string;
+    path: string;
+    type: string;
+    version: string;
+};

package/build/parachains/index.d.ts

@@ -0,0 +1,2 @@
+export * from './info.js';
+export * from './overview.js';

package/build/parachains/info.d.ts

@@ -0,0 +1,19 @@
+import type { Observable } from 'rxjs';
+import type { ParaId } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveParachainFull } from '../types.js';
+/**
+ * @name info
+ * @param {ParaId | number} id A unique numeric (non-negative integer) identifier for a parachain.
+ * @description Retrieves detailed information about a specific parachain.
+ * @example
+ * ```javascript
+ * await api.derive.parachains.info(1000, (info) => {
+ *   if (info) {
+ *     console.log(`Parachain ${info.id.toString()} is active: ${info.active}`);
+ *   } else {
+ *     console.log("Parachain information not available.");
+ *   }
+ * });
+ * ```
+*/
+export declare function info(instanceId: string, api: DeriveApi): (id: ParaId | number) => Observable<DeriveParachainFull | null>;

package/build/parachains/overview.d.ts

@@ -0,0 +1,15 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveParachain } from '../types.js';
+/**
+ * @name overview
+ * @description Retrieves an overview of all registered parachains.
+ * @example
+ * ```javascript
+ * await api.derive.parachains.overview((overview) => {
+ *   parachains.forEach(parachain => {
+ *     console.log(`Parachain ${parachain.id.toString()} is registered.`);
+ *   });
+ * });
+ * ```
+ */
+export declare function overview(instanceId: string, api: DeriveApi): () => Observable<DeriveParachain[]>;

package/build/parachains/types.d.ts

@@ -0,0 +1,38 @@
+import type { Bytes, Option, u32, Vec } from '@pezkuwi/types';
+import type { CollatorId, ParaId, ParaInfo, Retriable, UpwardMessage } from '@pezkuwi/types/interfaces';
+import type { ITuple } from '@pezkuwi/types/types';
+export type ParaInfoResult = Option<ParaInfo>;
+export type PendingSwap = Option<ParaId>;
+export type Active = Vec<ITuple<[ParaId, Option<ITuple<[CollatorId, Retriable]>>]>>;
+export type RetryQueue = Vec<Vec<ITuple<[ParaId, CollatorId]>>>;
+export type SelectedThreads = Vec<Vec<ITuple<[ParaId, CollatorId]>>>;
+export type Code = Bytes;
+export type Heads = Bytes;
+export type RelayDispatchQueue = Vec<UpwardMessage>;
+export type RelayDispatchQueueSize = ITuple<[u32, u32]>;
+export type DidUpdate = Option<Vec<ParaId>>;
+export interface DeriveParachainActive {
+    collatorId: CollatorId;
+    isRetriable: boolean;
+    retries: number;
+}
+export interface DeriveParachainInfo extends ParaInfo {
+    id: ParaId;
+    icon?: string;
+    name?: string;
+    owner?: string;
+}
+export interface DeriveParachain {
+    didUpdate: boolean;
+    pendingSwapId: ParaId | null;
+    id: ParaId;
+    info: DeriveParachainInfo | null;
+    relayDispatchQueueSize?: number;
+}
+export interface DeriveParachainFull extends DeriveParachain {
+    active: DeriveParachainActive | null;
+    heads: Bytes | null;
+    relayDispatchQueue: UpwardMessage[];
+    retryCollators: (CollatorId | null)[];
+    selectedCollators: (CollatorId | null)[];
+}

package/build/parachains/util.d.ts

@@ -0,0 +1,3 @@
+import type { ParaId } from '@pezkuwi/types/interfaces';
+import type { DidUpdate } from './types.js';
+export declare function didUpdateToBool(didUpdate: DidUpdate, id: ParaId): boolean;

package/build/session/index.d.ts

@@ -0,0 +1,3 @@
+export * from './indexes.js';
+export * from './info.js';
+export * from './progress.js';

package/build/session/indexes.d.ts

@@ -0,0 +1,15 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveSessionIndexes } from '../types.js';
+/**
+ * @name indexes
+ * @description Retrieves session-related index data, adapting to whether
+ * the chain has staking enabled.
+ * @example
+ * ```javascript
+ * api.derive.session.indexes((indexes) => {
+ *   console.log(`Current session index: ${indexes.currentIndex}`);
+ *   console.log(`Validator count: ${indexes.validatorCount}`);
+ * });
+ * ```
+ */
+export declare function indexes(instanceId: string, api: DeriveApi): () => Observable<DeriveSessionIndexes>;

package/build/session/info.d.ts

@@ -0,0 +1,13 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveSessionInfo } from '../types.js';
+/**
+ * @name info
+ * @description Retrieves all the session and era query and calculates specific values on it as the length of the session and eras.
+ * @example
+ * ```javascript
+ * api.derive.session.info((info) => {
+ *   console.log(`Session info ${JSON.stringify(info)}`);
+ * });
+ * ```
+ */
+export declare function info(instanceId: string, api: DeriveApi): () => Observable<DeriveSessionInfo>;

package/build/session/progress.d.ts

@@ -0,0 +1,47 @@
+import type { Observable } from 'rxjs';
+import type { BlockNumber } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveSessionProgress } from '../types.js';
+/**
+ * @name progress
+ * @description Retrieves session information and progress.
+ * @example
+ * ```javascript
+ * api.derive.session.progress((progress) => {
+ *   console.log(`Session progress ${JSON.stringify(progress)}`);
+ * });
+ * ```
+ */
+export declare function progress(instanceId: string, api: DeriveApi): () => Observable<DeriveSessionProgress>;
+/**
+ * @name eraLenght
+ * @description Retrieves the total length of the current era.
+ * @example
+ * ```javascript
+ * api.derive.session.eraLength((length) => {
+ *   console.log(`Current era length: ${length} sessions`);
+ * });
+ * ```
+ */
+export declare const eraLength: (instanceId: string, api: DeriveApi) => () => Observable<BlockNumber>;
+/**
+ * @name eraProgress
+ * @description Retrieves the progress of the current era.
+ * @example
+ * ```javascript
+ * api.derive.session.eraProgress((progress) => {
+ *   console.log(`Current era progress: ${progress} sessions`);
+ * });
+ * ```
+ */
+export declare const eraProgress: (instanceId: string, api: DeriveApi) => () => Observable<BlockNumber>;
+/**
+ * @name sessionProgress
+ * @description Retrieves the progress of the current session.
+ * @example
+ * ```javascript
+ *   api.derive.session.sessionProgress((progress) => {
+ *   console.log(`Current session progress: ${progress} slots`);
+ * });
+ * ```
+ */
+export declare const sessionProgress: (instanceId: string, api: DeriveApi) => () => Observable<BlockNumber>;

package/build/session/types.d.ts

@@ -0,0 +1,19 @@
+import type { Option, u32, u64 } from '@pezkuwi/types';
+import type { BlockNumber, EraIndex, Moment, SessionIndex } from '@pezkuwi/types/interfaces';
+export interface DeriveSessionIndexes {
+    activeEra: EraIndex;
+    activeEraStart: Option<Moment>;
+    currentEra: EraIndex;
+    currentIndex: SessionIndex;
+    validatorCount: u32;
+}
+export interface DeriveSessionInfo extends DeriveSessionIndexes {
+    eraLength: BlockNumber;
+    isEpoch: boolean;
+    sessionLength: u64;
+    sessionsPerEra: SessionIndex;
+}
+export interface DeriveSessionProgress extends DeriveSessionInfo {
+    eraProgress: BlockNumber;
+    sessionProgress: BlockNumber;
+}

package/build/society/candidates.d.ts

@@ -0,0 +1,12 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveSocietyCandidate } from '../types.js';
+/**
+ * @name candidate
+ * @description Retrieves the list of candidates for the society module.
+ * @example
+ * ```javascript
+ * const societyCandidates = await api.derive.society.candidates();
+ * console.log(societyCandidates);
+ * ```
+ */
+export declare function candidates(instanceId: string, api: DeriveApi): () => Observable<DeriveSocietyCandidate[]>;

package/build/society/index.d.ts

@@ -0,0 +1,4 @@
+export * from './candidates.js';
+export * from './info.js';
+export * from './member.js';
+export * from './members.js';

package/build/society/info.d.ts

@@ -0,0 +1,12 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveSociety } from '../types.js';
+/**
+ * @name info
+ * @description Get the overall info for a society.
+ * @example
+ * ```javascript
+ * const societyInfo = await api.derive.society.candidates();
+ * console.log(societyInfo);
+ * ```
+ */
+export declare function info(instanceId: string, api: DeriveApi): () => Observable<DeriveSociety>;

package/build/society/member.d.ts

@@ -0,0 +1,14 @@
+import type { Observable } from 'rxjs';
+import type { AccountId } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveSocietyMember } from '../types.js';
+/**
+ * @name member
+ * @description Get the member info for a society.
+ * @param { AccountId } accountId
+ * @example
+ * ```javascript
+ * const member = await api.derive.society.member(ALICE);
+ * console.log(member);
+ * ```
+ */
+export declare function member(instanceId: string, api: DeriveApi): (accountId: AccountId) => Observable<DeriveSocietyMember>;

package/build/society/members.d.ts

@@ -0,0 +1,14 @@
+import type { Observable } from 'rxjs';
+import type { AccountId } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveSocietyMember } from '../types.js';
+export declare function _members(instanceId: string, api: DeriveApi): (accountIds: AccountId[]) => Observable<DeriveSocietyMember[]>;
+/**
+ * @name members
+ * @description Get the society members.
+ * @example
+ * ```javascript
+ * const members = await api.derive.society.members();
+ * console.log(members);
+ * ```
+ */
+export declare function members(instanceId: string, api: DeriveApi): () => Observable<DeriveSocietyMember[]>;

package/build/society/types.d.ts

@@ -0,0 +1,27 @@
+import type { u32 } from '@pezkuwi/types';
+import type { AccountId, Balance, BalanceOf, BlockNumber, StrikeCount } from '@pezkuwi/types/interfaces';
+import type { PalletSocietyBid, PalletSocietyBidKind, PalletSocietyVote, PalletSocietyVouchingStatus } from '@pezkuwi/types/lookup';
+export interface DeriveSociety {
+    bids: PalletSocietyBid[];
+    defender?: AccountId | undefined;
+    hasDefender: boolean;
+    head?: AccountId | undefined;
+    founder?: AccountId | undefined;
+    maxMembers?: u32 | undefined;
+    pot: BalanceOf;
+}
+export interface DeriveSocietyCandidate {
+    accountId: AccountId;
+    kind: PalletSocietyBidKind;
+    value: Balance;
+    isSuspended: boolean;
+}
+export interface DeriveSocietyMember {
+    accountId: AccountId;
+    isDefenderVoter: boolean;
+    isSuspended: boolean;
+    payouts: [BlockNumber, Balance][];
+    strikes: StrikeCount;
+    vote?: PalletSocietyVote | undefined;
+    vouching?: PalletSocietyVouchingStatus | undefined;
+}

package/build/staking/account.d.ts

@@ -0,0 +1,31 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveStakingAccount } from '../types.js';
+import type { StakingQueryFlags } from './types.js';
+/**
+ * @name accounts
+ * @param {(Uint8Array | string)[]} accountIds List of account stashes
+ * @param {StakingQueryFlags} opts optional filtering flag
+ * @description From a list of stashes, fill in all the relevant staking details
+ * @example
+ * ```javascript
+ * const accounts = await api.derive.staking.accounts([
+ *  "149B17nn7zVL4SkLSNmANupEkGexUBAxVrdk4bbWFZYibkFc",
+ * ]);
+ * console.log("First account staking info:", accounts[0]);
+ * ```
+ */
+export declare function accounts(instanceId: string, api: DeriveApi): (accountIds: (Uint8Array | string)[], opts?: StakingQueryFlags) => Observable<DeriveStakingAccount[]>;
+/**
+ * @name account
+ * @param {(Uint8Array | string)} accountId AccountId of the stash.
+ * @param {StakingQueryFlags} opts (Optional) filtering flag.
+ * @description From a stash, retrieve the controllerId and fill in all the relevant staking details.
+ * @example
+ * ```javascript
+ * const accountStakingData = await api.derive.staking.account(
+ *   "149B17nn7zVL4SkLSNmANupEkGexUBAxVrdk4bbWFZYibkFc"
+ * );
+ * console.log(accountStakingData);
+ * ```
+ */
+export declare const account: (instanceId: string, api: DeriveApi) => (accountId: string | Uint8Array<ArrayBufferLike>, opts?: StakingQueryFlags) => Observable<DeriveStakingAccount>;

package/build/staking/cache.d.ts

@@ -0,0 +1,12 @@
+import type { EraIndex } from '@pezkuwi/types/interfaces';
+export declare function getEraCache<T>(CACHE_KEY: string, era: EraIndex, withActive?: boolean): [string, T | undefined];
+export declare function getEraMultiCache<T>(CACHE_KEY: string, eras: EraIndex[], withActive?: boolean): T[];
+export declare function setEraCache<T extends {
+    era: EraIndex;
+}>(cacheKey: string, withActive: boolean, value: T): T;
+export declare function setEraMultiCache<T extends {
+    era: EraIndex;
+}>(CACHE_KEY: string, withActive: boolean, values: T[]): T[];
+export declare function filterCachedEras<T extends {
+    era: EraIndex;
+}>(eras: EraIndex[], cached: T[], query: T[]): T[];

package/build/staking/currentPoints.d.ts

@@ -0,0 +1,13 @@
+import type { Observable } from 'rxjs';
+import type { PalletStakingEraRewardPoints } from '@pezkuwi/types/lookup';
+import type { DeriveApi } from '../types.js';
+/**
+ * @name currentPoints
+ * @description Retrieve the staking overview, including elected and points earned.
+ * @example
+ * ```javascript
+ * const currentPoints = await api.derive.staking.currentPoints();
+ * console.log(currentPoints.toHuman());
+ * ```
+ */
+export declare function currentPoints(instanceId: string, api: DeriveApi): () => Observable<PalletStakingEraRewardPoints>;

package/build/staking/electedInfo.d.ts

@@ -0,0 +1,23 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveStakingElected, StakingQueryFlags } from '../types.js';
+/**
+ * @name electedInfo
+ * @param {StakingQueryFlags} flags? (Optional) Query flags to filter the staking data.
+ * @param {number} page? (Optional) The page index for paginated results.
+ * @description Retrieves detailed staking information about the next elected validators and their associated staking data.
+ * @example
+ * ```javascript
+ * const { nextElected, validators, info } =
+ *   await api.derive.staking.electedInfo();
+ * console.log(
+ *   "Next Elected Validators:",
+ *   nextElected.map((acc) => acc.toString())
+ * );
+ * console.log(
+ *   "Current Validators:",
+ *   validators.map((acc) => acc.toString())
+ * );
+ * console.log("Validator Staking Info:", info);
+ * ```
+ */
+export declare function electedInfo(instanceId: string, api: DeriveApi): (flags?: StakingQueryFlags, page?: number) => Observable<DeriveStakingElected>;

package/build/staking/erasExposure.d.ts

@@ -0,0 +1,30 @@
+import type { Observable } from 'rxjs';
+import type { EraIndex } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveEraExposurePaged } from '../types.js';
+/**
+ * erasStakersClipped will be deprecated and replaced with erasStakersPaged. Therefore support is given for both
+ * storage queries until erasStakersClipped has been completely out of use.
+ */
+export declare function _eraExposure(instanceId: string, api: DeriveApi): (era: EraIndex, withActive?: boolean) => Observable<DeriveEraExposurePaged>;
+/**
+ * @name eraExposure
+ * @description Retrieves the staking exposure (nominators and total stake) for a specific era.
+ * @param {EraIndex} eras The staking era to query.
+ * @example
+ * ```javascript
+ * const era = api.createType("EraIndex", 1000);
+ * const exposure = await api.derive.staking.eraExposure(era);
+ * ```
+ */
+export declare const eraExposure: (instanceId: string, api: DeriveApi) => (era: EraIndex) => Observable<DeriveEraExposurePaged>;
+export declare const _erasExposure: (instanceId: string, api: DeriveApi) => (eras: EraIndex[], withActive: boolean) => Observable<DeriveEraExposurePaged[]>;
+/**
+ * @name erasExposure
+ * @description Retrieves staking exposure details for multiple past eras.
+ * @param {boolean} withActive? (Optional) Whether to include the active era in the result.
+ * @example
+ * ```javascript
+ * const exposure = await api.derive.staking.erasExposure(true);
+ * ```
+ */
+export declare const erasExposure: (instanceId: string, api: DeriveApi) => (withActive?: boolean) => Observable<DeriveEraExposurePaged[]>;

package/build/staking/erasHistoric.d.ts

@@ -0,0 +1,8 @@
+import type { Observable } from 'rxjs';
+import type { EraIndex } from '@pezkuwi/types/interfaces';
+import type { DeriveApi } from '../types.js';
+/**
+ * @name erasHistoric
+ * @param {boolean} withActive? (Optional) Whether to include the active era in the result.
+ */
+export declare function erasHistoric(instanceId: string, api: DeriveApi): (withActive?: boolean) => Observable<EraIndex[]>;

package/build/staking/erasPoints.d.ts

@@ -0,0 +1,18 @@
+import type { Observable } from 'rxjs';
+import type { EraIndex } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveEraPoints } from '../types.js';
+export declare function _erasPoints(instanceId: string, api: DeriveApi): (eras: EraIndex[], withActive: boolean) => Observable<DeriveEraPoints[]>;
+/**
+ * @name erasPoints
+ * @description Retrieves historical era points with its validators.
+ * @param {boolean} withActive? (Optional) Whether to include the active era in the result.
+ * @example
+ * ```javascript
+ * const points = await api.derive.staking.erasPoints(true);
+ * console.log(
+ *   "Validator points:",
+ *   points.map(({ era, eraPoints }) => `Era: ${era}, points ${eraPoints}`)
+ * );
+ * ```
+ */
+export declare const erasPoints: (instanceId: string, api: DeriveApi) => (withActive?: boolean) => Observable<DeriveEraPoints[]>;