import { Emitter } from 'mitt';
import type { HashObject } from '@chainsafe/as-sha256';

declare const AggregateAndProof: ContainerType<{
    aggregatorIndex: UintNumberType;
    aggregate: ContainerType<{
        aggregationBits: BitListType;
        data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
        }>;
        signature: ByteVectorType;
    }>;
    selectionProof: ByteVectorType;
}>;

declare type AggregateAndProof_2 = ValueOf<typeof ssz_2.AggregateAndProof>;

declare const AggregateAndProof_3: ContainerType<{
    aggregatorIndex: UintNumberType;
    aggregate: ContainerType<{
        aggregationBits: BitListType;
        data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
        }>;
        signature: ByteVectorType;
        committeeBits: BitVectorType;
    }>;
    selectionProof: ByteVectorType;
}>;

declare type AggregateAndProof_4 = ValueOf<typeof ssz_7.AggregateAndProof>;

declare const AggregationBits: BitListType;

declare type ApiClient = {
    [K in keyof Endpoints]: ApiClientMethods<Endpoints[K]>;
} & {
    httpClient: IHttpClient;
};

declare type ApiClientMethod<E extends Endpoint> = E["args"] extends void ? (init?: ApiRequestInit) => Promise<ApiResponse<E>> : HasOnlyOptionalProps<E["args"]> extends true ? (args?: E["args"], init?: ApiRequestInit) => Promise<ApiResponse<E>> : (args: E["args"], init?: ApiRequestInit) => Promise<ApiResponse<E>>;

declare type ApiClientMethods<Es extends Record<string, Endpoint>> = {
    [K in keyof Es]: ApiClientMethod<Es[K]>;
};

declare class ApiError extends Error {
    status: number;
    operationId: string;
    constructor(message: string, status: number, operationId: string);
}

declare type ApiRequestInit = ExtraRequestInit & OptionalRequestInit & RequestInit;

declare class ApiResponse<E extends Endpoint> extends Response {
    private definition;
    private _wireFormat?;
    private _rawBody?;
    private _errorBody?;
    private _meta?;
    private _value?;
    constructor(definition: RouteDefinitionExtra<E>, body?: BodyInit | null, init?: ResponseInit);
    wireFormat(): WireFormat | null;
    rawBody(): Promise<RawBody>;
    meta(): E["meta"];
    value(): E["return"];
    ssz(): Uint8Array;
    json(): Awaited<ReturnType<Response["json"]>>;
    assertOk(): void;
    error(): ApiError | null;
    errorBody(): Promise<string>;
    private resolvedRawBody;
    private resolvedErrorBody;
    private getErrorMessage;
}

declare class ArrayBasicTreeView<ElementType extends BasicType<unknown>> extends TreeView<ArrayBasicType<ElementType>> {
    readonly type: ArrayBasicType<ElementType>;
    protected tree: Tree;
    constructor(type: ArrayBasicType<ElementType>, tree: Tree);
    /**
     * Number of elements in the array. Equal to the Uint32 value of the Tree's length node
     */
    get length(): number;
    get node(): Node_2;
    /**
     * Get element at `index`. Returns the Basic element type value directly
     */
    get(index: number): ValueOf<ElementType>;
    /**
     * Set Basic element type `value` at `index`
     */
    set(index: number, value: ValueOf<ElementType>): void;
    /**
     * Get all values of this array as Basic element type values, from index zero to `this.length - 1`
     * @param values optional output parameter, if is provided it must be an array of the same length as this array
     */
    getAll(values?: ValueOf<ElementType>[]): ValueOf<ElementType>[];
}

declare class ArrayBasicTreeViewDU<ElementType extends BasicType<unknown>> extends TreeViewDU<ArrayBasicType<ElementType>> {
    readonly type: ArrayBasicType<ElementType>;
    protected _rootNode: Node_2;
    protected nodes: LeafNode[];
    protected readonly nodesChanged: Set<number>;
    protected _length: number;
    protected dirtyLength: boolean;
    private nodesPopulated;
    constructor(type: ArrayBasicType<ElementType>, _rootNode: Node_2, cache?: ArrayBasicTreeViewDUCache);
    /**
     * Number of elements in the array. Equal to un-commited length of the array
     */
    get length(): number;
    get node(): Node_2;
    get cache(): ArrayBasicTreeViewDUCache;
    /**
     * Get element at `index`. Returns the Basic element type value directly
     */
    get(index: number): ValueOf<ElementType>;
    /**
     * Set Basic element type `value` at `index`
     */
    set(index: number, value: ValueOf<ElementType>): void;
    /**
     * Get all values of this array as Basic element type values, from index zero to `this.length - 1`
     * @param values optional output parameter, if is provided it must be an array of the same length as this array
     */
    getAll(values?: ValueOf<ElementType>[]): ValueOf<ElementType>[];
    /**
     * When we need to compute HashComputations (hcByLevel != null):
     *   - if old _rootNode is hashed, then only need to put pending changes to hcByLevel
     *   - if old _rootNode is not hashed, need to traverse and put to hcByLevel
     */
    commit(hcOffset?: number, hcByLevel?: HashComputationLevel[] | null): void;
    protected clearCache(): void;
}

declare type ArrayBasicTreeViewDUCache = {
    nodes: LeafNode[];
    length: number;
    nodesPopulated: boolean;
};

/** Expected API of this View's type. This interface allows to break a recursive dependency between types and views */
declare type ArrayBasicType<ElementType extends BasicType<unknown>> = CompositeType<ValueOf<ElementType>[], TreeView<ArrayBasicType<ElementType>>, TreeViewDU<ArrayBasicType<ElementType>>> & ArrayType_2 & {
    readonly elementType: ElementType;
    readonly itemsPerChunk: number;
    readonly chunkDepth: number;
};

declare class ArrayCompositeTreeView<ElementType extends CompositeType<ValueOf<ElementType>, CompositeView<ElementType>, CompositeViewDU<ElementType>>> extends TreeView<ArrayCompositeType<ElementType>> {
    readonly type: ArrayCompositeType<ElementType>;
    protected tree: Tree;
    constructor(type: ArrayCompositeType<ElementType>, tree: Tree);
    /**
     * Number of elements in the array. Equal to the Uint32 value of the Tree's length node
     */
    get length(): number;
    /**
     * Returns the View's Tree rootNode
     */
    get node(): Node_2;
    /**
     * Get element at `index`. Returns a view of the Composite element type
     */
    get(index: number): CompositeView<ElementType>;
    /**
     * Get element at `index`. Returns a view of the Composite element type.
     * DOES NOT PROPAGATE CHANGES: use only for reads and to skip parent references.
     */
    getReadonly(index: number): CompositeView<ElementType>;
    /**
     * Set Composite element type `view` at `index`
     */
    set(index: number, view: CompositeView<ElementType>): void;
    /**
     * Returns an array of views of all elements in the array, from index zero to `this.length - 1`.
     * The returned views don't have a parent hook to this View's Tree, so changes in the returned views won't be
     * propagated upwards. To get linked element Views use `this.get()`
     * @param views optional output parameter, if is provided it must be an array of the same length as this array
     */
    getAllReadonly(views?: CompositeView<ElementType>[]): CompositeView<ElementType>[];
    /**
     * Returns an array of values of all elements in the array, from index zero to `this.length - 1`.
     * The returned values are not Views so any changes won't be propagated upwards.
     * To get linked element Views use `this.get()`
     * @param values optional output parameter, if is provided it must be an array of the same length as this array
     */
    getAllReadonlyValues(values?: ValueOf<ElementType>[]): ValueOf<ElementType>[];
}

declare class ArrayCompositeTreeViewDU<ElementType extends CompositeType<ValueOf<ElementType>, CompositeView<ElementType>, CompositeViewDU<ElementType>>> extends TreeViewDU<ArrayCompositeType<ElementType>> {
    readonly type: ArrayCompositeType<ElementType>;
    protected _rootNode: Node_2;
    protected nodes: Node_2[];
    protected caches: unknown[];
    protected readonly viewsChanged: Map<number, CompositeViewDU<ElementType>>;
    protected _length: number;
    protected dirtyLength: boolean;
    private nodesPopulated;
    constructor(type: ArrayCompositeType<ElementType>, _rootNode: Node_2, cache?: ArrayCompositeTreeViewDUCache);
    /**
     * Number of elements in the array. Equal to un-commited length of the array
     */
    get length(): number;
    get node(): Node_2;
    get cache(): ArrayCompositeTreeViewDUCache;
    /**
     * Get element at `index`. Returns a view of the Composite element type.
     *
     * NOTE: Assumes that any view created here will change and will call .commit() on it.
     * .get() should be used only for cases when something may mutate. To get all items without
     * triggering a .commit() in all them use .getAllReadOnly().
     */
    get(index: number): CompositeViewDU<ElementType>;
    /**
     * Get element at `index`. Returns a view of the Composite element type.
     * DOES NOT PROPAGATE CHANGES: use only for reads and to skip parent references.
     */
    getReadonly(index: number): CompositeViewDU<ElementType>;
    /**
     * Set Composite element type `view` at `index`
     */
    set(index: number, view: CompositeViewDU<ElementType>): void;
    /**
     * Returns all elements at every index, if an index is modified it will return the modified view.
     * No need to commit() before calling this function.
     * @param views optional output parameter, if is provided it must be an array of the same length as this array
     */
    getAllReadonly(views?: CompositeViewDU<ElementType>[]): CompositeViewDU<ElementType>[];
    /**
     * Apply `fn` to each ViewDU in the array.
     * Similar to getAllReadOnly(), no need to commit() before calling this function.
     * if an item is modified it will return the modified view.
     */
    forEach(fn: (viewDU: CompositeViewDU<ElementType>, index: number) => void): void;
    /**
     * WARNING: Returns all commited changes, if there are any pending changes commit them beforehand
     * @param values optional output parameter, if is provided it must be an array of the same length as this array
     */
    getAllReadonlyValues(values?: ValueOf<ElementType>[]): ValueOf<ElementType>[];
    /**
     * Apply `fn` to each value in the array
     */
    forEachValue(fn: (value: ValueOf<ElementType>, index: number) => void): void;
    /**
     * Get by range of indexes. Returns an array of views of the Composite element type.
     * This is similar to getAllReadonly() where we dont have to commit() before calling this function.
     */
    getReadonlyByRange(startIndex: number, count: number): CompositeViewDU<ElementType>[];
    /**
     * When we need to compute HashComputations (hcByLevel != null):
     *   - if old _rootNode is hashed, then only need to put pending changes to hcByLevel
     *   - if old _rootNode is not hashed, need to traverse and put to hcByLevel
     */
    commit(hcOffset?: number, hcByLevel?: HashComputationLevel[] | null): void;
    protected clearCache(): void;
    protected populateAllNodes(): void;
    /**
     * Similar to `populateAllNodes` but this does not require a commit() before reading all nodes.
     * If there are pendingChanges, they will NOT be included in the `nodes` array.
     */
    protected populateAllOldNodes(): void;
}

declare type ArrayCompositeTreeViewDUCache = {
    nodes: Node_2[];
    caches: unknown[];
    length: number;
    nodesPopulated: boolean;
};

/** Expected API of this View's type. This interface allows to break a recursive dependency between types and views */
declare type ArrayCompositeType<ElementType extends CompositeType<unknown, CompositeView<ElementType>, CompositeViewDU<ElementType>>> = CompositeType<ValueOf<ElementType>[], unknown, unknown> & ArrayType_2 & {
    readonly elementType: ElementType;
    readonly chunkDepth: number;
};

/**
 * These interfaces are consistent across all backings.
 * As long as these interfaces are respected, the backing can be abstracted entirely.
 */
declare interface ArrayLike_2<T> {
    [n: number]: T;
    readonly length: number;
    [Symbol.iterator](): Iterator<T>;
}

/**
 * Array: ordered homogeneous collection
 */
declare abstract class ArrayType<ElementType extends Type<unknown>, TV, TVDU> extends CompositeType<ValueOf<ElementType>[], TV, TVDU> {
    readonly elementType: ElementType;
    abstract readonly itemsPerChunk: number;
    protected abstract readonly defaultLen: number;
    constructor(elementType: ElementType, cachePermanentRootStruct?: boolean);
    defaultValue(): ValueOf<ElementType>[];
    abstract tree_getLength(node: Node_2): number;
    getPropertyType(): Type<unknown>;
    getPropertyGindex(prop: string | number): bigint;
    getIndexProperty(index: number): string | number;
    tree_getLeafGindices(rootGindex: bigint, rootNode?: Node_2): bigint[];
    fromJson(json: unknown): ValueOf<ElementType>[];
    toJson(value: ValueOf<ElementType>[]): unknown;
    clone(value: ValueOf<ElementType>[]): ValueOf<ElementType>[];
    equals(a: ValueOf<ElementType>[], b: ValueOf<ElementType>[]): boolean;
}

/** Common type for both ArrayBasicType and ArrayCompositeTypesrc/view/arrayBasic.ts */
declare type ArrayType_2 = {
    /** INTERNAL METHOD: Return the length of this type from an Array's root node */
    tree_getLength(node: Node_2): number;
    /** INTERNAL METHOD: Mutate a tree's rootNode with a new length value */
    tree_setLength(tree: Tree, length: number): void;
    /** INTERNAL METHOD: Return the chunks node from a root node */
    tree_getChunksNode(rootNode: Node_2): Node_2;
    /** INTERNAL METHOD: Return the offset from root for HashComputation */
    tree_chunksNodeOffset(): number;
    /** INTERNAL METHOD: Return a new root node with changed chunks node and length */
    tree_setChunksNode(rootNode: Node_2, chunksNode: Node_2, newLength: number | null, hcOffset?: number, hcByLevel?: HashComputationLevel[] | null): Node_2;
};

/**
 * Proof that the state referenced in `update.finalityHeader.stateRoot` includes
 * ```ts
 * state = {
 *   finalizedCheckpoint: {
 *     root: update.header
 *   }
 * }
 * ```
 *
 * Where `hashTreeRoot(state) == update.finalityHeader.stateRoot`
 */
declare function assertValidFinalityProof(update: LightClientFinalityUpdate): void;

/**
 *
 * @param config the beacon node config
 * @param syncCommittee the sync committee update
 * @param update the light client update for validation
 */
declare function assertValidLightClientUpdate(config: BeaconConfig, syncCommittee: SyncCommitteeFast, update: LightClientUpdate_9): void;

/**
 * Assert valid signature for `signedHeader` with provided `syncCommittee`.
 *
 * update.syncCommitteeSignature signs over the block at the previous slot of the state it is included.
 * ```py
 * previous_slot = max(state.slot, Slot(1)) - Slot(1)
 * domain = get_domain(state, DOMAIN_SYNC_COMMITTEE, compute_epoch_at_slot(previous_slot))
 * signing_root = compute_signing_root(get_block_root_at_slot(state, previous_slot), domain)
 * ```
 * Ref: https://github.com/ethereum/consensus-specs/blob/v1.1.10/specs/altair/beacon-chain.md#sync-aggregate-processing
 *
 * @param syncCommittee SyncPeriod that signed this update: `computeSyncPeriodAtSlot(update.header.slot) - 1`
 * @param forkVersion ForkVersion that was used to sign the update
 * @param signedHeaderRoot Takes header root instead of the head itself to prevent re-hashing on SSE
 */
declare function assertValidSignedHeader(config: BeaconConfig, syncCommittee: SyncCommitteeFast, syncAggregate: ts_2.SyncAggregate, signedHeaderRoot: Root_2, signedHeaderSlot: Slot_2): void;

/**
 * Proof that the state referenced in `update.header.stateRoot` includes
 * ```ts
 * state = {
 *   nextSyncCommittee: update.nextSyncCommittee
 * }
 * ```
 *
 * Where `hashTreeRoot(state) == update.header.stateRoot`
 */
declare function assertValidSyncCommitteeProof(update: LightClientUpdate_9): void;

declare function assertZeroHashes(rootArray: Root_2[], expectedLength: number, errorMessage: string): void;

declare const Attestation: ContainerType<{
    aggregationBits: BitListType;
    data: ContainerType<{
        slot: UintNumberType;
        index: UintNumberType;
        beaconBlockRoot: ByteVectorType;
        source: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
        }>;
        target: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
        }>;
    }>;
    signature: ByteVectorType;
}>;

declare type Attestation_2 = ValueOf<typeof ssz_2.Attestation>;

declare type Attestation_3 = ValueOf<typeof ssz_7.Attestation>;

declare const Attestation_4: ContainerType<{
    aggregationBits: BitListType;
    data: ContainerType<{
        slot: UintNumberType;
        index: UintNumberType;
        beaconBlockRoot: ByteVectorType;
        source: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
        }>;
        target: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
        }>;
    }>;
    signature: ByteVectorType;
    committeeBits: BitVectorType;
}>;

declare type Attestation_5<F extends ForkName = ForkAll> = TypesByFork[F]["Attestation"];

declare const AttestationData: ContainerType<{
    slot: UintNumberType;
    index: UintNumberType;
    beaconBlockRoot: ByteVectorType;
    source: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
    target: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
}>;

declare type AttestationData_2 = ValueOf<typeof ssz_2.AttestationData>;

/** Same as `AttestationData` but epoch, slot and index are not bounded and must be a bigint */
declare const AttestationDataBigint: ContainerType<{
    slot: UintBigintType;
    index: UintBigintType;
    beaconBlockRoot: ByteVectorType;
    source: ContainerType<{
        epoch: UintBigintType;
        root: ByteVectorType;
    }>;
    target: ContainerType<{
        epoch: UintBigintType;
        root: ByteVectorType;
    }>;
}>;

declare type AttestationDataBigint_2 = ValueOf<typeof ssz_2.AttestationDataBigint>;

declare type AttestationList = AttestationListPhase0 | AttestationListElectra;

declare type AttestationListElectra = ValueOf<typeof AttestationListTypeElectra>;

declare type AttestationListPhase0 = ValueOf<typeof AttestationListTypePhase0>;

declare const AttestationListTypeElectra: ArrayType<Type<ValueOfFields<    {
aggregationBits: BitListType;
data: ContainerType<    {
slot: UintNumberType;
index: UintNumberType;
beaconBlockRoot: ByteVectorType;
source: ContainerType<    {
epoch: UintNumberType;
root: ByteVectorType;
}>;
target: ContainerType<    {
epoch: UintNumberType;
root: ByteVectorType;
}>;
}>;
signature: ByteVectorType;
committeeBits: BitVectorType;
}>>, unknown, unknown>;

declare const AttestationListTypePhase0: ArrayType<Type<ValueOfFields<    {
aggregationBits: BitListType;
data: ContainerType<    {
slot: UintNumberType;
index: UintNumberType;
beaconBlockRoot: ByteVectorType;
source: ContainerType<    {
epoch: UintNumberType;
root: ByteVectorType;
}>;
target: ContainerType<    {
epoch: UintNumberType;
root: ByteVectorType;
}>;
}>;
signature: ByteVectorType;
}>>, unknown, unknown>;

/**
 * Rewards for a single set of (ideal or actual depending on usage) attestations. Reward value is in Gwei
 */
declare type AttestationsReward = ValueOf<typeof AttestationsRewardType>;

declare type AttestationsRewards = ValueOf<typeof AttestationsRewardsType>;

declare const AttestationsRewardsType: ContainerType<{
    idealRewards: ArrayType<Type<ValueOfFields<    {
    /** Reward for head vote. Could be negative to indicate penalty */
    head: UintNumberType;
    /** Reward for target vote. Could be negative to indicate penalty */
    target: UintNumberType;
    /** Reward for source vote. Could be negative to indicate penalty */
    source: UintNumberType;
    /** Inclusion delay reward (phase0 only) */
    inclusionDelay: UintNumberType;
    /** Inactivity penalty. Should be a negative number to indicate penalty */
    inactivity: UintNumberType;
    effectiveBalance: UintNumberType;
    }>>, unknown, unknown>;
    totalRewards: ArrayType<Type<ValueOfFields<    {
    /** Reward for head vote. Could be negative to indicate penalty */
    head: UintNumberType;
    /** Reward for target vote. Could be negative to indicate penalty */
    target: UintNumberType;
    /** Reward for source vote. Could be negative to indicate penalty */
    source: UintNumberType;
    /** Inclusion delay reward (phase0 only) */
    inclusionDelay: UintNumberType;
    /** Inactivity penalty. Should be a negative number to indicate penalty */
    inactivity: UintNumberType;
    validatorIndex: UintNumberType;
    }>>, unknown, unknown>;
}>;

declare const AttestationsRewardType: ContainerType<{
    /** Reward for head vote. Could be negative to indicate penalty */
    head: UintNumberType;
    /** Reward for target vote. Could be negative to indicate penalty */
    target: UintNumberType;
    /** Reward for source vote. Could be negative to indicate penalty */
    source: UintNumberType;
    /** Inclusion delay reward (phase0 only) */
    inclusionDelay: UintNumberType;
    /** Inactivity penalty. Should be a negative number to indicate penalty */
    inactivity: UintNumberType;
}>;

declare type AttestationSubnets = ValueOf<typeof ssz_2.AttestationSubnets>;

declare const AttestationSubnets_2: BitVectorType;

declare type AttesterDuty = ValueOf<typeof AttesterDutyType>;

declare type AttesterDutyList = ValueOf<typeof AttesterDutyListType>;

declare const AttesterDutyListType: ArrayType<Type<ValueOfFields<    {
/** The validator's public key, uniquely identifying them */
pubkey: ByteVectorType;
/** Index of validator in validator registry */
validatorIndex: UintNumberType;
/** Index of the committee */
committeeIndex: UintNumberType;
/** Number of validators in committee */
committeeLength: UintNumberType;
/** Number of committees at the provided slot */
committeesAtSlot: UintNumberType;
/** Index of validator in committee */
validatorCommitteeIndex: UintNumberType;
/** The slot at which the validator must attest */
slot: UintNumberType;
}>>, unknown, unknown>;

declare const AttesterDutyType: ContainerType<{
    /** The validator's public key, uniquely identifying them */
    pubkey: ByteVectorType;
    /** Index of validator in validator registry */
    validatorIndex: UintNumberType;
    /** Index of the committee */
    committeeIndex: UintNumberType;
    /** Number of validators in committee */
    committeeLength: UintNumberType;
    /** Number of committees at the provided slot */
    committeesAtSlot: UintNumberType;
    /** Index of validator in committee */
    validatorCommitteeIndex: UintNumberType;
    /** The slot at which the validator must attest */
    slot: UintNumberType;
}>;

declare const AttesterSlashing: ContainerType<{
    attestation1: ContainerType<{
        attestingIndices: ListBasicType<UintNumberType>;
        data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
            }>;
        }>;
        signature: ByteVectorType;
    }>;
    attestation2: ContainerType<{
        attestingIndices: ListBasicType<UintNumberType>;
        data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
            }>;
        }>;
        signature: ByteVectorType;
    }>;
}>;

declare type AttesterSlashing_2 = ValueOf<typeof ssz_2.AttesterSlashing>;

declare const AttesterSlashing_3: ContainerType<{
    attestation1: ContainerType<{
        attestingIndices: ListBasicType<UintNumberType>;
        data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
            }>;
        }>;
        signature: ByteVectorType;
    }>;
    attestation2: ContainerType<{
        attestingIndices: ListBasicType<UintNumberType>;
        data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
            }>;
        }>;
        signature: ByteVectorType;
    }>;
}>;

declare type AttesterSlashing_4 = ValueOf<typeof ssz_7.AttesterSlashing>;

declare type AttesterSlashing_5<F extends ForkName = ForkAll> = TypesByFork[F]["AttesterSlashing"];

declare type AttesterSlashingList = AttesterSlashingListPhase0 | AttesterSlashingListElectra;

declare type AttesterSlashingListElectra = ValueOf<typeof AttesterSlashingListTypeElectra>;

declare type AttesterSlashingListPhase0 = ValueOf<typeof AttesterSlashingListTypePhase0>;

declare const AttesterSlashingListTypeElectra: ArrayType<Type<ValueOfFields<    {
attestation1: ContainerType<    {
attestingIndices: ListBasicType<UintNumberType>;
data: ContainerType<    {
slot: UintBigintType;
index: UintBigintType;
beaconBlockRoot: ByteVectorType;
source: ContainerType<    {
epoch: UintBigintType;
root: ByteVectorType;
}>;
target: ContainerType<    {
epoch: UintBigintType;
root: ByteVectorType;
}>;
}>;
signature: ByteVectorType;
}>;
attestation2: ContainerType<    {
attestingIndices: ListBasicType<UintNumberType>;
data: ContainerType<    {
slot: UintBigintType;
index: UintBigintType;
beaconBlockRoot: ByteVectorType;
source: ContainerType<    {
epoch: UintBigintType;
root: ByteVectorType;
}>;
target: ContainerType<    {
epoch: UintBigintType;
root: ByteVectorType;
}>;
}>;
signature: ByteVectorType;
}>;
}>>, unknown, unknown>;

declare const AttesterSlashingListTypePhase0: ArrayType<Type<ValueOfFields<    {
attestation1: ContainerType<    {
attestingIndices: ListBasicType<UintNumberType>;
data: ContainerType<    {
slot: UintBigintType;
index: UintBigintType;
beaconBlockRoot: ByteVectorType;
source: ContainerType<    {
epoch: UintBigintType;
root: ByteVectorType;
}>;
target: ContainerType<    {
epoch: UintBigintType;
root: ByteVectorType;
}>;
}>;
signature: ByteVectorType;
}>;
attestation2: ContainerType<    {
attestingIndices: ListBasicType<UintNumberType>;
data: ContainerType<    {
slot: UintBigintType;
index: UintBigintType;
beaconBlockRoot: ByteVectorType;
source: ContainerType<    {
epoch: UintBigintType;
root: ByteVectorType;
}>;
target: ContainerType<    {
epoch: UintBigintType;
root: ByteVectorType;
}>;
}>;
signature: ByteVectorType;
}>;
}>>, unknown, unknown>;

declare const AttestingIndices: ListBasicType<UintNumberType>;

declare const Balances: ListUintNum64Type;

/** Expected API of this View's type. This interface allows to break a recursive dependency between types and views */
declare type BasicContainerTypeGeneric<Fields extends Record<string, Type<unknown>>> = CompositeType<ValueOfFields<Fields>, ContainerTreeViewType<Fields>, unknown> & {
    readonly fields: Fields;
    readonly fieldsEntries: (FieldEntry<Fields> | FieldEntry<NonOptionalFields<Fields>>)[];
};

/**
 * Represents a basic type as defined in the spec:
 * https://github.com/ethereum/consensus-specs/blob/v1.6.1/ssz/simple-serialize.md#basic-types
 */
declare abstract class BasicType<V> extends Type<V> {
    readonly isBasic = true;
    readonly depth = 0;
    readonly maxChunkCount = 1;
    abstract readonly byteLength: number;
    value_serializedSize(): number;
    tree_serializedSize(): number;
    protected assertValidSize(size: number): void;
    hashTreeRoot(value: V): Uint8Array;
    hashTreeRootInto(value: V, output: Uint8Array, offset: number): void;
    clone(value: V): V;
    equals(a: V, b: V): boolean;
    /** INTERNAL METHOD: Efficiently get a value from a LeafNode (not packed) */
    abstract tree_getFromNode(leafNode: LeafNode): V;
    /** INTERNAL METHOD: Efficiently set a value to a LeafNode (not packed) */
    abstract tree_setToNode(leafNode: LeafNode, value: V): void;
    /** INTERNAL METHOD: Efficiently get a value from a LeafNode (packed) */
    abstract tree_getFromPackedNode(leafNode: LeafNode, index: number): V;
    /** INTERNAL METHOD: Efficiently set a value to a LeafNode (packed) */
    abstract tree_setToPackedNode(leafNode: LeafNode, index: number, value: V): void;
}

declare namespace beacon {
    export {
        getDefinitions_5 as getDefinitions,
        block,
        pool,
        state,
        rewards,
        BlockHeaderResponse,
        BlockId,
        BroadcastValidation,
        EpochCommitteeResponse,
        EpochSyncCommitteeResponse,
        FinalityCheckpoints,
        StateId,
        ValidatorBalance,
        ValidatorId,
        ValidatorIdentities,
        ValidatorResponse,
        ValidatorStatus,
        Endpoints_2 as Endpoints
    }
}

declare const BeaconBlock: ContainerType<{
    slot: UintNumberType;
    proposerIndex: UintNumberType;
    parentRoot: ByteVectorType;
    stateRoot: ByteVectorType;
    body: ContainerType<{
        randaoReveal: ByteVectorType;
        eth1Data: ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
        }>;
        graffiti: ByteVectorType;
        proposerSlashings: ListCompositeType<ContainerType<{
            signedHeader1: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
        }>>;
        attesterSlashings: ListCompositeType<ContainerType<{
            attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
        }>>;
        attestations: ListCompositeType<ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>>;
        deposits: ListCompositeType<ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
            }>;
        }>>;
        voluntaryExits: ListCompositeType<ContainerType<{
            message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
        }>>;
    }>;
}>;

declare type BeaconBlock_10 = ValueOf<typeof ssz_6.BeaconBlock>;

declare const BeaconBlock_11: ContainerType<{
    slot: UintNumberType;
    proposerIndex: UintNumberType;
    parentRoot: ByteVectorType;
    stateRoot: ByteVectorType;
    body: ContainerType<{
        randaoReveal: ByteVectorType;
        eth1Data: ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
        }>;
        graffiti: ByteVectorType;
        proposerSlashings: ListCompositeType<ContainerType<{
            signedHeader1: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
        }>>;
        attesterSlashings: ListCompositeType<ContainerType<{
            attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
        }>>;
        attestations: ListCompositeType<ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
            committeeBits: BitVectorType;
        }>>;
        deposits: ListCompositeType<ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
            }>;
        }>>;
        voluntaryExits: ListCompositeType<ContainerType<{
            message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
        }>>;
        syncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
        }>;
        executionPayload: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactions: ListCompositeType<ByteListType>;
            withdrawals: ListCompositeType<ContainerType<{
                index: UintNumberType;
                validatorIndex: UintNumberType;
                address: ExecutionAddressType;
                amount: UintBigintType;
            }>>;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
        }>;
        blsToExecutionChanges: ListCompositeType<ContainerType<{
            message: ContainerType<{
                validatorIndex: UintNumberType;
                fromBlsPubkey: ByteVectorType;
                toExecutionAddress: ExecutionAddressType;
            }>;
            signature: ByteVectorType;
        }>>;
        blobKzgCommitments: ListCompositeType<ByteVectorType>;
        executionRequests: ContainerType<{
            deposits: ListCompositeType<ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                index: UintBigintType;
            }>>;
            withdrawals: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                validatorPubkey: ByteVectorType;
                amount: UintBigintType;
            }>>;
            consolidations: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                sourcePubkey: ByteVectorType;
                targetPubkey: ByteVectorType;
            }>>;
        }>;
    }>;
}>;

declare type BeaconBlock_12 = ValueOf<typeof ssz_7.BeaconBlock>;

declare const BeaconBlock_13: ContainerType<{
    slot: UintNumberType;
    proposerIndex: UintNumberType;
    parentRoot: ByteVectorType;
    stateRoot: ByteVectorType;
    body: ContainerType<{
        randaoReveal: ByteVectorType;
        eth1Data: ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
        }>;
        graffiti: ByteVectorType;
        proposerSlashings: ListCompositeType<ContainerType<{
            signedHeader1: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
        }>>;
        attesterSlashings: ListCompositeType<ContainerType<{
            attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
        }>>;
        attestations: ListCompositeType<ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
            committeeBits: BitVectorType;
        }>>;
        deposits: ListCompositeType<ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
            }>;
        }>>;
        voluntaryExits: ListCompositeType<ContainerType<{
            message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
        }>>;
        syncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
        }>;
        executionPayload: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactions: ListCompositeType<ByteListType>;
            withdrawals: ListCompositeType<ContainerType<{
                index: UintNumberType;
                validatorIndex: UintNumberType;
                address: ExecutionAddressType;
                amount: UintBigintType;
            }>>;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
        }>;
        blsToExecutionChanges: ListCompositeType<ContainerType<{
            message: ContainerType<{
                validatorIndex: UintNumberType;
                fromBlsPubkey: ByteVectorType;
                toExecutionAddress: ExecutionAddressType;
            }>;
            signature: ByteVectorType;
        }>>;
        blobKzgCommitments: ListCompositeType<ByteVectorType>;
        executionRequests: ContainerType<{
            deposits: ListCompositeType<ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                index: UintBigintType;
            }>>;
            withdrawals: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                validatorPubkey: ByteVectorType;
                amount: UintBigintType;
            }>>;
            consolidations: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                sourcePubkey: ByteVectorType;
                targetPubkey: ByteVectorType;
            }>>;
        }>;
    }>;
}>;

declare type BeaconBlock_14 = ValueOf<typeof ssz_8.BeaconBlock>;

declare const BeaconBlock_15: ContainerType<{
    slot: UintNumberType;
    proposerIndex: UintNumberType;
    parentRoot: ByteVectorType;
    stateRoot: ByteVectorType;
    body: ContainerType<{
        randaoReveal: ByteVectorType;
        eth1Data: ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
        }>;
        graffiti: ByteVectorType;
        proposerSlashings: ListCompositeType<ContainerType<{
            signedHeader1: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
        }>>;
        attesterSlashings: ListCompositeType<ContainerType<{
            attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
        }>>;
        attestations: ListCompositeType<ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
            committeeBits: BitVectorType;
        }>>;
        deposits: ListCompositeType<ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
            }>;
        }>>;
        voluntaryExits: ListCompositeType<ContainerType<{
            message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
        }>>;
        syncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
        }>;
        blsToExecutionChanges: ListCompositeType<ContainerType<{
            message: ContainerType<{
                validatorIndex: UintNumberType;
                fromBlsPubkey: ByteVectorType;
                toExecutionAddress: ExecutionAddressType;
            }>;
            signature: ByteVectorType;
        }>>;
        signedExecutionPayloadBid: ContainerType<{
            message: ContainerType<{
                parentBlockHash: ByteVectorType;
                parentBlockRoot: ByteVectorType;
                blockHash: ByteVectorType;
                prevRandao: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                gasLimit: UintBigintType;
                builderIndex: UintNumberType;
                slot: UintNumberType;
                value: UintNumberType;
                executionPayment: UintNumberType;
                blobKzgCommitments: ListCompositeType<ByteVectorType>;
                executionRequestsRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        payloadAttestations: ListCompositeType<ContainerType<{
            aggregationBits: BitVectorType;
            data: ContainerType<{
                beaconBlockRoot: ByteVectorType;
                slot: UintNumberType;
                payloadPresent: BooleanType;
                blobDataAvailable: BooleanType;
            }>;
            signature: ByteVectorType;
        }>>;
        parentExecutionRequests: ContainerType<{
            deposits: ListCompositeType<ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                index: UintBigintType;
            }>>;
            withdrawals: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                validatorPubkey: ByteVectorType;
                amount: UintBigintType;
            }>>;
            consolidations: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                sourcePubkey: ByteVectorType;
                targetPubkey: ByteVectorType;
            }>>;
        }>;
    }>;
}>;

declare type BeaconBlock_16 = ValueOf<typeof ssz_9.BeaconBlock>;

declare type BeaconBlock_17<F extends ForkAll = ForkAll> = TypesByFork[F]["BeaconBlock"];

declare type BeaconBlock_2 = ValueOf<typeof ssz_2.BeaconBlock>;

declare const BeaconBlock_3: ContainerType<{
    slot: UintNumberType;
    proposerIndex: UintNumberType;
    parentRoot: ByteVectorType;
    stateRoot: ByteVectorType;
    body: ContainerType<{
        randaoReveal: ByteVectorType;
        eth1Data: ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
        }>;
        graffiti: ByteVectorType;
        proposerSlashings: ListCompositeType<ContainerType<{
            signedHeader1: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
        }>>;
        attesterSlashings: ListCompositeType<ContainerType<{
            attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
        }>>;
        attestations: ListCompositeType<ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>>;
        deposits: ListCompositeType<ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
            }>;
        }>>;
        voluntaryExits: ListCompositeType<ContainerType<{
            message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
        }>>;
        syncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
        }>;
    }>;
}>;

declare type BeaconBlock_4 = ValueOf<typeof ssz_3.BeaconBlock>;

declare const BeaconBlock_5: ContainerType<{
    slot: UintNumberType;
    proposerIndex: UintNumberType;
    parentRoot: ByteVectorType;
    stateRoot: ByteVectorType;
    body: ContainerType<{
        randaoReveal: ByteVectorType;
        eth1Data: ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
        }>;
        graffiti: ByteVectorType;
        proposerSlashings: ListCompositeType<ContainerType<{
            signedHeader1: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
        }>>;
        attesterSlashings: ListCompositeType<ContainerType<{
            attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
        }>>;
        attestations: ListCompositeType<ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>>;
        deposits: ListCompositeType<ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
            }>;
        }>>;
        voluntaryExits: ListCompositeType<ContainerType<{
            message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
        }>>;
        syncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
        }>;
        executionPayload: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactions: ListCompositeType<ByteListType>;
        }>;
    }>;
}>;

declare type BeaconBlock_6 = ValueOf<typeof ssz_4.BeaconBlock>;

declare const BeaconBlock_7: ContainerType<{
    slot: UintNumberType;
    proposerIndex: UintNumberType;
    parentRoot: ByteVectorType;
    stateRoot: ByteVectorType;
    body: ContainerType<{
        randaoReveal: ByteVectorType;
        eth1Data: ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
        }>;
        graffiti: ByteVectorType;
        proposerSlashings: ListCompositeType<ContainerType<{
            signedHeader1: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
        }>>;
        attesterSlashings: ListCompositeType<ContainerType<{
            attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
        }>>;
        attestations: ListCompositeType<ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>>;
        deposits: ListCompositeType<ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
            }>;
        }>>;
        voluntaryExits: ListCompositeType<ContainerType<{
            message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
        }>>;
        syncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
        }>;
        executionPayload: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactions: ListCompositeType<ByteListType>;
            withdrawals: ListCompositeType<ContainerType<{
                index: UintNumberType;
                validatorIndex: UintNumberType;
                address: ExecutionAddressType;
                amount: UintBigintType;
            }>>;
        }>;
        blsToExecutionChanges: ListCompositeType<ContainerType<{
            message: ContainerType<{
                validatorIndex: UintNumberType;
                fromBlsPubkey: ByteVectorType;
                toExecutionAddress: ExecutionAddressType;
            }>;
            signature: ByteVectorType;
        }>>;
    }>;
}>;

declare type BeaconBlock_8 = ValueOf<typeof ssz_5.BeaconBlock>;

declare const BeaconBlock_9: ContainerType<{
    slot: UintNumberType;
    proposerIndex: UintNumberType;
    parentRoot: ByteVectorType;
    stateRoot: ByteVectorType;
    body: ContainerType<{
        randaoReveal: ByteVectorType;
        eth1Data: ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
        }>;
        graffiti: ByteVectorType;
        proposerSlashings: ListCompositeType<ContainerType<{
            signedHeader1: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
        }>>;
        attesterSlashings: ListCompositeType<ContainerType<{
            attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
        }>>;
        attestations: ListCompositeType<ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>>;
        deposits: ListCompositeType<ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
            }>;
        }>>;
        voluntaryExits: ListCompositeType<ContainerType<{
            message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
        }>>;
        syncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
        }>;
        executionPayload: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactions: ListCompositeType<ByteListType>;
            withdrawals: ListCompositeType<ContainerType<{
                index: UintNumberType;
                validatorIndex: UintNumberType;
                address: ExecutionAddressType;
                amount: UintBigintType;
            }>>;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
        }>;
        blsToExecutionChanges: ListCompositeType<ContainerType<{
            message: ContainerType<{
                validatorIndex: UintNumberType;
                fromBlsPubkey: ByteVectorType;
                toExecutionAddress: ExecutionAddressType;
            }>;
            signature: ByteVectorType;
        }>>;
        blobKzgCommitments: ListCompositeType<ByteVectorType>;
    }>;
}>;

declare const BeaconBlockBody: ContainerType<{
    randaoReveal: ByteVectorType;
    eth1Data: ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
    }>;
    graffiti: ByteVectorType;
    proposerSlashings: ListCompositeType<ContainerType<{
        signedHeader1: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        signedHeader2: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
    }>>;
    attesterSlashings: ListCompositeType<ContainerType<{
        attestation1: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        attestation2: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
    }>>;
    attestations: ListCompositeType<ContainerType<{
        aggregationBits: BitListType;
        data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
        }>;
        signature: ByteVectorType;
    }>>;
    deposits: ListCompositeType<ContainerType<{
        proof: VectorCompositeType<ByteVectorType>;
        data: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
        }>;
    }>>;
    voluntaryExits: ListCompositeType<ContainerType<{
        message: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
        }>;
        signature: ByteVectorType;
    }>>;
}>;

declare type BeaconBlockBody_10 = ValueOf<typeof ssz_6.BeaconBlockBody>;

declare const BeaconBlockBody_11: ContainerType<{
    randaoReveal: ByteVectorType;
    eth1Data: ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
    }>;
    graffiti: ByteVectorType;
    proposerSlashings: ListCompositeType<ContainerType<{
        signedHeader1: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        signedHeader2: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
    }>>;
    attesterSlashings: ListCompositeType<ContainerType<{
        attestation1: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        attestation2: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
    }>>;
    attestations: ListCompositeType<ContainerType<{
        aggregationBits: BitListType;
        data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
        }>;
        signature: ByteVectorType;
        committeeBits: BitVectorType;
    }>>;
    deposits: ListCompositeType<ContainerType<{
        proof: VectorCompositeType<ByteVectorType>;
        data: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
        }>;
    }>>;
    voluntaryExits: ListCompositeType<ContainerType<{
        message: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
        }>;
        signature: ByteVectorType;
    }>>;
    syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
    }>;
    executionPayload: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactions: ListCompositeType<ByteListType>;
        withdrawals: ListCompositeType<ContainerType<{
            index: UintNumberType;
            validatorIndex: UintNumberType;
            address: ExecutionAddressType;
            amount: UintBigintType;
        }>>;
        blobGasUsed: UintBigintType;
        excessBlobGas: UintBigintType;
    }>;
    blsToExecutionChanges: ListCompositeType<ContainerType<{
        message: ContainerType<{
            validatorIndex: UintNumberType;
            fromBlsPubkey: ByteVectorType;
            toExecutionAddress: ExecutionAddressType;
        }>;
        signature: ByteVectorType;
    }>>;
    blobKzgCommitments: ListCompositeType<ByteVectorType>;
    executionRequests: ContainerType<{
        deposits: ListCompositeType<ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            index: UintBigintType;
        }>>;
        withdrawals: ListCompositeType<ContainerType<{
            sourceAddress: ExecutionAddressType;
            validatorPubkey: ByteVectorType;
            amount: UintBigintType;
        }>>;
        consolidations: ListCompositeType<ContainerType<{
            sourceAddress: ExecutionAddressType;
            sourcePubkey: ByteVectorType;
            targetPubkey: ByteVectorType;
        }>>;
    }>;
}>;

declare type BeaconBlockBody_12 = ValueOf<typeof ssz_7.BeaconBlockBody>;

declare const BeaconBlockBody_13: ContainerType<{
    randaoReveal: ByteVectorType;
    eth1Data: ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
    }>;
    graffiti: ByteVectorType;
    proposerSlashings: ListCompositeType<ContainerType<{
        signedHeader1: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        signedHeader2: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
    }>>;
    attesterSlashings: ListCompositeType<ContainerType<{
        attestation1: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        attestation2: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
    }>>;
    attestations: ListCompositeType<ContainerType<{
        aggregationBits: BitListType;
        data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
        }>;
        signature: ByteVectorType;
        committeeBits: BitVectorType;
    }>>;
    deposits: ListCompositeType<ContainerType<{
        proof: VectorCompositeType<ByteVectorType>;
        data: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
        }>;
    }>>;
    voluntaryExits: ListCompositeType<ContainerType<{
        message: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
        }>;
        signature: ByteVectorType;
    }>>;
    syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
    }>;
    blsToExecutionChanges: ListCompositeType<ContainerType<{
        message: ContainerType<{
            validatorIndex: UintNumberType;
            fromBlsPubkey: ByteVectorType;
            toExecutionAddress: ExecutionAddressType;
        }>;
        signature: ByteVectorType;
    }>>;
    signedExecutionPayloadBid: ContainerType<{
        message: ContainerType<{
            parentBlockHash: ByteVectorType;
            parentBlockRoot: ByteVectorType;
            blockHash: ByteVectorType;
            prevRandao: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            gasLimit: UintBigintType;
            builderIndex: UintNumberType;
            slot: UintNumberType;
            value: UintNumberType;
            executionPayment: UintNumberType;
            blobKzgCommitments: ListCompositeType<ByteVectorType>;
            executionRequestsRoot: ByteVectorType;
        }>;
        signature: ByteVectorType;
    }>;
    payloadAttestations: ListCompositeType<ContainerType<{
        aggregationBits: BitVectorType;
        data: ContainerType<{
            beaconBlockRoot: ByteVectorType;
            slot: UintNumberType;
            payloadPresent: BooleanType;
            blobDataAvailable: BooleanType;
        }>;
        signature: ByteVectorType;
    }>>;
    parentExecutionRequests: ContainerType<{
        deposits: ListCompositeType<ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            index: UintBigintType;
        }>>;
        withdrawals: ListCompositeType<ContainerType<{
            sourceAddress: ExecutionAddressType;
            validatorPubkey: ByteVectorType;
            amount: UintBigintType;
        }>>;
        consolidations: ListCompositeType<ContainerType<{
            sourceAddress: ExecutionAddressType;
            sourcePubkey: ByteVectorType;
            targetPubkey: ByteVectorType;
        }>>;
    }>;
}>;

declare type BeaconBlockBody_14 = ValueOf<typeof ssz_9.BeaconBlockBody>;

declare type BeaconBlockBody_15<F extends ForkAll = ForkAll> = TypesByFork[F]["BeaconBlockBody"];

declare type BeaconBlockBody_2 = ValueOf<typeof ssz_2.BeaconBlockBody>;

declare const BeaconBlockBody_3: ContainerType<{
    randaoReveal: ByteVectorType;
    eth1Data: ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
    }>;
    graffiti: ByteVectorType;
    proposerSlashings: ListCompositeType<ContainerType<{
        signedHeader1: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        signedHeader2: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
    }>>;
    attesterSlashings: ListCompositeType<ContainerType<{
        attestation1: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        attestation2: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
    }>>;
    attestations: ListCompositeType<ContainerType<{
        aggregationBits: BitListType;
        data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
        }>;
        signature: ByteVectorType;
    }>>;
    deposits: ListCompositeType<ContainerType<{
        proof: VectorCompositeType<ByteVectorType>;
        data: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
        }>;
    }>>;
    voluntaryExits: ListCompositeType<ContainerType<{
        message: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
        }>;
        signature: ByteVectorType;
    }>>;
    syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
    }>;
}>;

declare type BeaconBlockBody_4 = ValueOf<typeof ssz_3.BeaconBlockBody>;

declare const BeaconBlockBody_5: ContainerType<{
    randaoReveal: ByteVectorType;
    eth1Data: ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
    }>;
    graffiti: ByteVectorType;
    proposerSlashings: ListCompositeType<ContainerType<{
        signedHeader1: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        signedHeader2: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
    }>>;
    attesterSlashings: ListCompositeType<ContainerType<{
        attestation1: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        attestation2: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
    }>>;
    attestations: ListCompositeType<ContainerType<{
        aggregationBits: BitListType;
        data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
        }>;
        signature: ByteVectorType;
    }>>;
    deposits: ListCompositeType<ContainerType<{
        proof: VectorCompositeType<ByteVectorType>;
        data: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
        }>;
    }>>;
    voluntaryExits: ListCompositeType<ContainerType<{
        message: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
        }>;
        signature: ByteVectorType;
    }>>;
    syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
    }>;
    executionPayload: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactions: ListCompositeType<ByteListType>;
    }>;
}>;

declare type BeaconBlockBody_6 = ValueOf<typeof ssz_4.BeaconBlockBody>;

declare const BeaconBlockBody_7: ContainerType<{
    randaoReveal: ByteVectorType;
    eth1Data: ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
    }>;
    graffiti: ByteVectorType;
    proposerSlashings: ListCompositeType<ContainerType<{
        signedHeader1: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        signedHeader2: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
    }>>;
    attesterSlashings: ListCompositeType<ContainerType<{
        attestation1: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        attestation2: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
    }>>;
    attestations: ListCompositeType<ContainerType<{
        aggregationBits: BitListType;
        data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
        }>;
        signature: ByteVectorType;
    }>>;
    deposits: ListCompositeType<ContainerType<{
        proof: VectorCompositeType<ByteVectorType>;
        data: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
        }>;
    }>>;
    voluntaryExits: ListCompositeType<ContainerType<{
        message: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
        }>;
        signature: ByteVectorType;
    }>>;
    syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
    }>;
    executionPayload: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactions: ListCompositeType<ByteListType>;
        withdrawals: ListCompositeType<ContainerType<{
            index: UintNumberType;
            validatorIndex: UintNumberType;
            address: ExecutionAddressType;
            amount: UintBigintType;
        }>>;
    }>;
    blsToExecutionChanges: ListCompositeType<ContainerType<{
        message: ContainerType<{
            validatorIndex: UintNumberType;
            fromBlsPubkey: ByteVectorType;
            toExecutionAddress: ExecutionAddressType;
        }>;
        signature: ByteVectorType;
    }>>;
}>;

declare type BeaconBlockBody_8 = ValueOf<typeof ssz_5.BeaconBlockBody>;

declare const BeaconBlockBody_9: ContainerType<{
    randaoReveal: ByteVectorType;
    eth1Data: ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
    }>;
    graffiti: ByteVectorType;
    proposerSlashings: ListCompositeType<ContainerType<{
        signedHeader1: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        signedHeader2: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
    }>>;
    attesterSlashings: ListCompositeType<ContainerType<{
        attestation1: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        attestation2: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
    }>>;
    attestations: ListCompositeType<ContainerType<{
        aggregationBits: BitListType;
        data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
        }>;
        signature: ByteVectorType;
    }>>;
    deposits: ListCompositeType<ContainerType<{
        proof: VectorCompositeType<ByteVectorType>;
        data: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
        }>;
    }>>;
    voluntaryExits: ListCompositeType<ContainerType<{
        message: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
        }>;
        signature: ByteVectorType;
    }>>;
    syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
    }>;
    executionPayload: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactions: ListCompositeType<ByteListType>;
        withdrawals: ListCompositeType<ContainerType<{
            index: UintNumberType;
            validatorIndex: UintNumberType;
            address: ExecutionAddressType;
            amount: UintBigintType;
        }>>;
        blobGasUsed: UintBigintType;
        excessBlobGas: UintBigintType;
    }>;
    blsToExecutionChanges: ListCompositeType<ContainerType<{
        message: ContainerType<{
            validatorIndex: UintNumberType;
            fromBlsPubkey: ByteVectorType;
            toExecutionAddress: ExecutionAddressType;
        }>;
        signature: ByteVectorType;
    }>>;
    blobKzgCommitments: ListCompositeType<ByteVectorType>;
}>;

/** BeaconBlockHeader where slot is bounded by the clock, and values above it are invalid */
declare const BeaconBlockHeader: ContainerType<{
    slot: UintNumberType;
    proposerIndex: UintNumberType;
    parentRoot: ByteVectorType;
    stateRoot: ByteVectorType;
    bodyRoot: ByteVectorType;
}>;

declare type BeaconBlockHeader_2 = ValueOf<typeof ssz_2.BeaconBlockHeader>;

/** BeaconBlockHeader where slot is NOT bounded by the clock, i.e. slashings. So slot is a bigint. */
declare const BeaconBlockHeaderBigint: ContainerType<{
    slot: UintBigintType;
    proposerIndex: UintNumberType;
    parentRoot: ByteVectorType;
    stateRoot: ByteVectorType;
    bodyRoot: ByteVectorType;
}>;

declare type BeaconBlockHeaderBigint_2 = ValueOf<typeof ssz_2.BeaconBlockHeaderBigint>;

declare const BeaconBlocksByHeadRequest: ContainerType<{
    beaconRoot: ByteVectorType;
    count: UintNumberType;
}>;

declare type BeaconBlocksByHeadRequest_2 = ValueOf<typeof ssz_8.BeaconBlocksByHeadRequest>;

declare const BeaconBlocksByRangeRequest: ContainerType<{
    startSlot: UintNumberType;
    count: UintNumberType;
    step: UintNumberType;
}>;

declare type BeaconBlocksByRangeRequest_2 = ValueOf<typeof ssz_2.BeaconBlocksByRangeRequest>;

declare type BeaconCommitteeSelection = ValueOf<typeof BeaconCommitteeSelectionType>;

declare type BeaconCommitteeSelectionList = ValueOf<typeof BeaconCommitteeSelectionListType>;

declare const BeaconCommitteeSelectionListType: ArrayType<Type<ValueOfFields<    {
/** Index of the validator */
validatorIndex: UintNumberType;
/** The slot at which a validator is assigned to attest */
slot: UintNumberType;
/** The `slot_signature` calculated by the validator for the upcoming attestation slot */
selectionProof: ByteVectorType;
}>>, unknown, unknown>;

/**
 * From https://github.com/ethereum/beacon-APIs/pull/224
 */
declare const BeaconCommitteeSelectionType: ContainerType<{
    /** Index of the validator */
    validatorIndex: UintNumberType;
    /** The slot at which a validator is assigned to attest */
    slot: UintNumberType;
    /** The `slot_signature` calculated by the validator for the upcoming attestation slot */
    selectionProof: ByteVectorType;
}>;

declare type BeaconCommitteeSubscription = ValueOf<typeof BeaconCommitteeSubscriptionType>;

declare type BeaconCommitteeSubscriptionList = ValueOf<typeof BeaconCommitteeSubscriptionListType>;

declare const BeaconCommitteeSubscriptionListType: ArrayType<Type<ValueOfFields<    {
validatorIndex: UintNumberType;
committeeIndex: UintNumberType;
committeesAtSlot: UintNumberType;
slot: UintNumberType;
isAggregator: BooleanType;
}>>, unknown, unknown>;

declare const BeaconCommitteeSubscriptionType: ContainerType<{
    validatorIndex: UintNumberType;
    committeeIndex: UintNumberType;
    committeesAtSlot: UintNumberType;
    slot: UintNumberType;
    isAggregator: BooleanType;
}>;

declare type BeaconConfig = ChainForkConfig & CachedGenesis;

declare type BeaconEvent = {
    [K in EventType]: {
        type: K;
        message: EventData[K];
    };
}[EventType];

declare const BeaconState: ContainerType<{
    genesisTime: UintNumberType;
    genesisValidatorsRoot: ByteVectorType;
    slot: UintNumberType;
    fork: ContainerType<{
        previousVersion: ByteVectorType;
        currentVersion: ByteVectorType;
        epoch: UintNumberType;
    }>;
    latestBlockHeader: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
    }>;
    blockRoots: VectorCompositeType<ByteVectorType>;
    stateRoots: VectorCompositeType<ByteVectorType>;
    historicalRoots: ListCompositeType<ByteVectorType>;
    eth1Data: ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
    }>;
    eth1DataVotes: ListCompositeType<ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
    }>>;
    eth1DepositIndex: UintNumberType;
    validators: ListCompositeType<ValidatorNodeStructType>;
    balances: ListUintNum64Type;
    randaoMixes: VectorCompositeType<ByteVectorType>;
    slashings: VectorBasicType<UintNumberType>;
    previousEpochAttestations: ListCompositeType<ContainerType<{
        aggregationBits: BitListType;
        data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
        }>;
        inclusionDelay: UintNumberType;
        proposerIndex: UintNumberType;
    }>>;
    currentEpochAttestations: ListCompositeType<ContainerType<{
        aggregationBits: BitListType;
        data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
        }>;
        inclusionDelay: UintNumberType;
        proposerIndex: UintNumberType;
    }>>;
    justificationBits: BitVectorType;
    previousJustifiedCheckpoint: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
    currentJustifiedCheckpoint: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
    finalizedCheckpoint: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
}>;

declare type BeaconState_10 = ValueOf<typeof ssz_6.BeaconState>;

declare const BeaconState_11: ContainerType<{
    genesisTime: UintNumberType;
    genesisValidatorsRoot: ByteVectorType;
    slot: UintNumberType;
    fork: ContainerType<{
        previousVersion: ByteVectorType;
        currentVersion: ByteVectorType;
        epoch: UintNumberType;
    }>;
    latestBlockHeader: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
    }>;
    blockRoots: VectorCompositeType<ByteVectorType>;
    stateRoots: VectorCompositeType<ByteVectorType>;
    historicalRoots: ListCompositeType<ByteVectorType>;
    eth1Data: ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
    }>;
    eth1DataVotes: ListCompositeType<ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
    }>>;
    eth1DepositIndex: UintNumberType;
    validators: ListCompositeType<ValidatorNodeStructType>;
    balances: ListUintNum64Type;
    randaoMixes: VectorCompositeType<ByteVectorType>;
    slashings: VectorBasicType<UintNumberType>;
    previousEpochParticipation: ListBasicType<UintNumberType>;
    currentEpochParticipation: ListBasicType<UintNumberType>;
    justificationBits: BitVectorType;
    previousJustifiedCheckpoint: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
    currentJustifiedCheckpoint: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
    finalizedCheckpoint: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
    inactivityScores: ListBasicType<UintNumberType>;
    currentSyncCommittee: ContainerType<{
        pubkeys: VectorCompositeType<ByteVectorType>;
        aggregatePubkey: ByteVectorType;
    }>;
    nextSyncCommittee: ContainerType<{
        pubkeys: VectorCompositeType<ByteVectorType>;
        aggregatePubkey: ByteVectorType;
    }>;
    latestExecutionPayloadHeader: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactionsRoot: ByteVectorType;
        withdrawalsRoot: ByteVectorType;
        blobGasUsed: UintBigintType;
        excessBlobGas: UintBigintType;
    }>;
    nextWithdrawalIndex: UintNumberType;
    nextWithdrawalValidatorIndex: UintNumberType;
    historicalSummaries: ListCompositeType<ContainerType<{
        blockSummaryRoot: ByteVectorType;
        stateSummaryRoot: ByteVectorType;
    }>>;
    depositRequestsStartIndex: UintBigintType;
    depositBalanceToConsume: UintBigintType;
    exitBalanceToConsume: UintBigintType;
    earliestExitEpoch: UintNumberType;
    consolidationBalanceToConsume: UintBigintType;
    earliestConsolidationEpoch: UintNumberType;
    pendingDeposits: ListCompositeType<ContainerType<{
        pubkey: ByteVectorType;
        withdrawalCredentials: ByteVectorType;
        amount: UintNumberType;
        signature: ByteVectorType;
        slot: UintNumberType;
    }>>;
    pendingPartialWithdrawals: ListCompositeType<ContainerType<{
        validatorIndex: UintNumberType;
        amount: UintBigintType;
        withdrawableEpoch: UintNumberType;
    }>>;
    pendingConsolidations: ListCompositeType<ContainerType<{
        sourceIndex: UintNumberType;
        targetIndex: UintNumberType;
    }>>;
}>;

declare type BeaconState_12 = ValueOf<typeof ssz_7.BeaconState>;

declare const BeaconState_13: ContainerType<{
    genesisTime: UintNumberType;
    genesisValidatorsRoot: ByteVectorType;
    slot: UintNumberType;
    fork: ContainerType<{
        previousVersion: ByteVectorType;
        currentVersion: ByteVectorType;
        epoch: UintNumberType;
    }>;
    latestBlockHeader: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
    }>;
    blockRoots: VectorCompositeType<ByteVectorType>;
    stateRoots: VectorCompositeType<ByteVectorType>;
    historicalRoots: ListCompositeType<ByteVectorType>;
    eth1Data: ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
    }>;
    eth1DataVotes: ListCompositeType<ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
    }>>;
    eth1DepositIndex: UintNumberType;
    validators: ListCompositeType<ValidatorNodeStructType>;
    balances: ListUintNum64Type;
    randaoMixes: VectorCompositeType<ByteVectorType>;
    slashings: VectorBasicType<UintNumberType>;
    previousEpochParticipation: ListBasicType<UintNumberType>;
    currentEpochParticipation: ListBasicType<UintNumberType>;
    justificationBits: BitVectorType;
    previousJustifiedCheckpoint: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
    currentJustifiedCheckpoint: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
    finalizedCheckpoint: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
    inactivityScores: ListBasicType<UintNumberType>;
    currentSyncCommittee: ContainerType<{
        pubkeys: VectorCompositeType<ByteVectorType>;
        aggregatePubkey: ByteVectorType;
    }>;
    nextSyncCommittee: ContainerType<{
        pubkeys: VectorCompositeType<ByteVectorType>;
        aggregatePubkey: ByteVectorType;
    }>;
    latestExecutionPayloadHeader: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactionsRoot: ByteVectorType;
        withdrawalsRoot: ByteVectorType;
        blobGasUsed: UintBigintType;
        excessBlobGas: UintBigintType;
    }>;
    nextWithdrawalIndex: UintNumberType;
    nextWithdrawalValidatorIndex: UintNumberType;
    historicalSummaries: ListCompositeType<ContainerType<{
        blockSummaryRoot: ByteVectorType;
        stateSummaryRoot: ByteVectorType;
    }>>;
    depositRequestsStartIndex: UintBigintType;
    depositBalanceToConsume: UintBigintType;
    exitBalanceToConsume: UintBigintType;
    earliestExitEpoch: UintNumberType;
    consolidationBalanceToConsume: UintBigintType;
    earliestConsolidationEpoch: UintNumberType;
    pendingDeposits: ListCompositeType<ContainerType<{
        pubkey: ByteVectorType;
        withdrawalCredentials: ByteVectorType;
        amount: UintNumberType;
        signature: ByteVectorType;
        slot: UintNumberType;
    }>>;
    pendingPartialWithdrawals: ListCompositeType<ContainerType<{
        validatorIndex: UintNumberType;
        amount: UintBigintType;
        withdrawableEpoch: UintNumberType;
    }>>;
    pendingConsolidations: ListCompositeType<ContainerType<{
        sourceIndex: UintNumberType;
        targetIndex: UintNumberType;
    }>>;
    proposerLookahead: VectorBasicType<UintNumberType>;
}>;

declare type BeaconState_14 = ValueOf<typeof ssz_8.BeaconState>;

declare const BeaconState_15: ContainerType<{
    genesisTime: UintNumberType;
    genesisValidatorsRoot: ByteVectorType;
    slot: UintNumberType;
    fork: ContainerType<{
        previousVersion: ByteVectorType;
        currentVersion: ByteVectorType;
        epoch: UintNumberType;
    }>;
    latestBlockHeader: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
    }>;
    blockRoots: VectorCompositeType<ByteVectorType>;
    stateRoots: VectorCompositeType<ByteVectorType>;
    historicalRoots: ListCompositeType<ByteVectorType>;
    eth1Data: ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
    }>;
    eth1DataVotes: ListCompositeType<ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
    }>>;
    eth1DepositIndex: UintNumberType;
    validators: ListCompositeType<ValidatorNodeStructType>;
    balances: ListUintNum64Type;
    randaoMixes: VectorCompositeType<ByteVectorType>;
    slashings: VectorBasicType<UintNumberType>;
    previousEpochParticipation: ListBasicType<UintNumberType>;
    currentEpochParticipation: ListBasicType<UintNumberType>;
    justificationBits: BitVectorType;
    previousJustifiedCheckpoint: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
    currentJustifiedCheckpoint: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
    finalizedCheckpoint: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
    inactivityScores: ListBasicType<UintNumberType>;
    currentSyncCommittee: ContainerType<{
        pubkeys: VectorCompositeType<ByteVectorType>;
        aggregatePubkey: ByteVectorType;
    }>;
    nextSyncCommittee: ContainerType<{
        pubkeys: VectorCompositeType<ByteVectorType>;
        aggregatePubkey: ByteVectorType;
    }>;
    latestBlockHash: ByteVectorType;
    nextWithdrawalIndex: UintNumberType;
    nextWithdrawalValidatorIndex: UintNumberType;
    historicalSummaries: ListCompositeType<ContainerType<{
        blockSummaryRoot: ByteVectorType;
        stateSummaryRoot: ByteVectorType;
    }>>;
    depositRequestsStartIndex: UintBigintType;
    depositBalanceToConsume: UintBigintType;
    exitBalanceToConsume: UintBigintType;
    earliestExitEpoch: UintNumberType;
    consolidationBalanceToConsume: UintBigintType;
    earliestConsolidationEpoch: UintNumberType;
    pendingDeposits: ListCompositeType<ContainerType<{
        pubkey: ByteVectorType;
        withdrawalCredentials: ByteVectorType;
        amount: UintNumberType;
        signature: ByteVectorType;
        slot: UintNumberType;
    }>>;
    pendingPartialWithdrawals: ListCompositeType<ContainerType<{
        validatorIndex: UintNumberType;
        amount: UintBigintType;
        withdrawableEpoch: UintNumberType;
    }>>;
    pendingConsolidations: ListCompositeType<ContainerType<{
        sourceIndex: UintNumberType;
        targetIndex: UintNumberType;
    }>>;
    proposerLookahead: VectorBasicType<UintNumberType>;
    builders: ListCompositeType<ContainerType<{
        pubkey: ByteVectorType;
        version: UintNumberType;
        executionAddress: ExecutionAddressType;
        balance: UintNumberType;
        depositEpoch: UintNumberType;
        withdrawableEpoch: UintNumberType;
    }>>;
    nextWithdrawalBuilderIndex: UintNumberType;
    executionPayloadAvailability: BitVectorType;
    builderPendingPayments: VectorCompositeType<ContainerType<{
        weight: UintNumberType;
        withdrawal: ContainerType<{
            feeRecipient: ExecutionAddressType;
            amount: UintNumberType;
            builderIndex: UintNumberType;
        }>;
    }>>;
    builderPendingWithdrawals: ListCompositeType<ContainerType<{
        feeRecipient: ExecutionAddressType;
        amount: UintNumberType;
        builderIndex: UintNumberType;
    }>>;
    latestExecutionPayloadBid: ContainerType<{
        parentBlockHash: ByteVectorType;
        parentBlockRoot: ByteVectorType;
        blockHash: ByteVectorType;
        prevRandao: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        gasLimit: UintBigintType;
        builderIndex: UintNumberType;
        slot: UintNumberType;
        value: UintNumberType;
        executionPayment: UintNumberType;
        blobKzgCommitments: ListCompositeType<ByteVectorType>;
        executionRequestsRoot: ByteVectorType;
    }>;
    payloadExpectedWithdrawals: ListCompositeType<ContainerType<{
        index: UintNumberType;
        validatorIndex: UintNumberType;
        address: ExecutionAddressType;
        amount: UintBigintType;
    }>>;
    ptcWindow: VectorCompositeType<VectorBasicType<UintNumberType>>;
}>;

declare type BeaconState_16 = ValueOf<typeof ssz_9.BeaconState>;

declare type BeaconState_17<F extends ForkName = ForkAll> = TypesByFork[F]["BeaconState"];

declare type BeaconState_2 = ValueOf<typeof ssz_2.BeaconState>;

declare const BeaconState_3: ContainerType<{
    genesisTime: UintNumberType;
    genesisValidatorsRoot: ByteVectorType;
    slot: UintNumberType;
    fork: ContainerType<{
        previousVersion: ByteVectorType;
        currentVersion: ByteVectorType;
        epoch: UintNumberType;
    }>;
    latestBlockHeader: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
    }>;
    blockRoots: VectorCompositeType<ByteVectorType>;
    stateRoots: VectorCompositeType<ByteVectorType>;
    historicalRoots: ListCompositeType<ByteVectorType>;
    eth1Data: ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
    }>;
    eth1DataVotes: ListCompositeType<ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
    }>>;
    eth1DepositIndex: UintNumberType;
    validators: ListCompositeType<ValidatorNodeStructType>;
    balances: ListUintNum64Type;
    randaoMixes: VectorCompositeType<ByteVectorType>;
    slashings: VectorBasicType<UintNumberType>;
    previousEpochParticipation: ListBasicType<UintNumberType>;
    currentEpochParticipation: ListBasicType<UintNumberType>;
    justificationBits: BitVectorType;
    previousJustifiedCheckpoint: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
    currentJustifiedCheckpoint: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
    finalizedCheckpoint: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
    inactivityScores: ListBasicType<UintNumberType>;
    currentSyncCommittee: ContainerType<{
        pubkeys: VectorCompositeType<ByteVectorType>;
        aggregatePubkey: ByteVectorType;
    }>;
    nextSyncCommittee: ContainerType<{
        pubkeys: VectorCompositeType<ByteVectorType>;
        aggregatePubkey: ByteVectorType;
    }>;
}>;

declare type BeaconState_4 = ValueOf<typeof ssz_3.BeaconState>;

declare const BeaconState_5: ContainerType<{
    genesisTime: UintNumberType;
    genesisValidatorsRoot: ByteVectorType;
    slot: UintNumberType;
    fork: ContainerType<{
        previousVersion: ByteVectorType;
        currentVersion: ByteVectorType;
        epoch: UintNumberType;
    }>;
    latestBlockHeader: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
    }>;
    blockRoots: VectorCompositeType<ByteVectorType>;
    stateRoots: VectorCompositeType<ByteVectorType>;
    historicalRoots: ListCompositeType<ByteVectorType>;
    eth1Data: ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
    }>;
    eth1DataVotes: ListCompositeType<ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
    }>>;
    eth1DepositIndex: UintNumberType;
    validators: ListCompositeType<ValidatorNodeStructType>;
    balances: ListUintNum64Type;
    randaoMixes: VectorCompositeType<ByteVectorType>;
    slashings: VectorBasicType<UintNumberType>;
    previousEpochParticipation: ListBasicType<UintNumberType>;
    currentEpochParticipation: ListBasicType<UintNumberType>;
    justificationBits: BitVectorType;
    previousJustifiedCheckpoint: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
    currentJustifiedCheckpoint: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
    finalizedCheckpoint: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
    inactivityScores: ListBasicType<UintNumberType>;
    currentSyncCommittee: ContainerType<{
        pubkeys: VectorCompositeType<ByteVectorType>;
        aggregatePubkey: ByteVectorType;
    }>;
    nextSyncCommittee: ContainerType<{
        pubkeys: VectorCompositeType<ByteVectorType>;
        aggregatePubkey: ByteVectorType;
    }>;
    latestExecutionPayloadHeader: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactionsRoot: ByteVectorType;
    }>;
}>;

declare type BeaconState_6 = ValueOf<typeof ssz_4.BeaconState>;

declare const BeaconState_7: ContainerType<{
    genesisTime: UintNumberType;
    genesisValidatorsRoot: ByteVectorType;
    slot: UintNumberType;
    fork: ContainerType<{
        previousVersion: ByteVectorType;
        currentVersion: ByteVectorType;
        epoch: UintNumberType;
    }>;
    latestBlockHeader: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
    }>;
    blockRoots: VectorCompositeType<ByteVectorType>;
    stateRoots: VectorCompositeType<ByteVectorType>;
    historicalRoots: ListCompositeType<ByteVectorType>;
    eth1Data: ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
    }>;
    eth1DataVotes: ListCompositeType<ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
    }>>;
    eth1DepositIndex: UintNumberType;
    validators: ListCompositeType<ValidatorNodeStructType>;
    balances: ListUintNum64Type;
    randaoMixes: VectorCompositeType<ByteVectorType>;
    slashings: VectorBasicType<UintNumberType>;
    previousEpochParticipation: ListBasicType<UintNumberType>;
    currentEpochParticipation: ListBasicType<UintNumberType>;
    justificationBits: BitVectorType;
    previousJustifiedCheckpoint: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
    currentJustifiedCheckpoint: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
    finalizedCheckpoint: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
    inactivityScores: ListBasicType<UintNumberType>;
    currentSyncCommittee: ContainerType<{
        pubkeys: VectorCompositeType<ByteVectorType>;
        aggregatePubkey: ByteVectorType;
    }>;
    nextSyncCommittee: ContainerType<{
        pubkeys: VectorCompositeType<ByteVectorType>;
        aggregatePubkey: ByteVectorType;
    }>;
    latestExecutionPayloadHeader: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactionsRoot: ByteVectorType;
        withdrawalsRoot: ByteVectorType;
    }>;
    nextWithdrawalIndex: UintNumberType;
    nextWithdrawalValidatorIndex: UintNumberType;
    historicalSummaries: ListCompositeType<ContainerType<{
        blockSummaryRoot: ByteVectorType;
        stateSummaryRoot: ByteVectorType;
    }>>;
}>;

declare type BeaconState_8 = ValueOf<typeof ssz_5.BeaconState>;

declare const BeaconState_9: ContainerType<{
    genesisTime: UintNumberType;
    genesisValidatorsRoot: ByteVectorType;
    slot: UintNumberType;
    fork: ContainerType<{
        previousVersion: ByteVectorType;
        currentVersion: ByteVectorType;
        epoch: UintNumberType;
    }>;
    latestBlockHeader: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
    }>;
    blockRoots: VectorCompositeType<ByteVectorType>;
    stateRoots: VectorCompositeType<ByteVectorType>;
    historicalRoots: ListCompositeType<ByteVectorType>;
    eth1Data: ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
    }>;
    eth1DataVotes: ListCompositeType<ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
    }>>;
    eth1DepositIndex: UintNumberType;
    validators: ListCompositeType<ValidatorNodeStructType>;
    balances: ListUintNum64Type;
    randaoMixes: VectorCompositeType<ByteVectorType>;
    slashings: VectorBasicType<UintNumberType>;
    previousEpochParticipation: ListBasicType<UintNumberType>;
    currentEpochParticipation: ListBasicType<UintNumberType>;
    justificationBits: BitVectorType;
    previousJustifiedCheckpoint: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
    currentJustifiedCheckpoint: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
    finalizedCheckpoint: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
    inactivityScores: ListBasicType<UintNumberType>;
    currentSyncCommittee: ContainerType<{
        pubkeys: VectorCompositeType<ByteVectorType>;
        aggregatePubkey: ByteVectorType;
    }>;
    nextSyncCommittee: ContainerType<{
        pubkeys: VectorCompositeType<ByteVectorType>;
        aggregatePubkey: ByteVectorType;
    }>;
    latestExecutionPayloadHeader: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactionsRoot: ByteVectorType;
        withdrawalsRoot: ByteVectorType;
        blobGasUsed: UintBigintType;
        excessBlobGas: UintBigintType;
    }>;
    nextWithdrawalIndex: UintNumberType;
    nextWithdrawalValidatorIndex: UintNumberType;
    historicalSummaries: ListCompositeType<ContainerType<{
        blockSummaryRoot: ByteVectorType;
        stateSummaryRoot: ByteVectorType;
    }>>;
}>;

/**
 * BitArray may be represented as an array of bits or compressed into an array of bytes.
 *
 * **Array of bits**:
 * Require 8.87 bytes per bit, so for 512 bits = 4500 bytes.
 * Are 'faster' to iterate with native tooling but are as fast as array of bytes with precomputed caches.
 *
 * **Array of bytes**:
 * Require an average cost of Uint8Array in JS = 220 bytes for 32 bytes, so for 512 bits = 220 bytes.
 * With precomputed boolean arrays per bytes value are as fast to iterate as an array of bits above.
 *
 * This BitArray implementation will represent data as a Uint8Array since it's very cheap to deserialize and can be as
 * fast to iterate as a native array of booleans, precomputing boolean arrays (total memory cost of 16000 bytes).
 */
declare class BitArray {
    /** Underlying BitArray Uint8Array data */
    readonly uint8Array: Uint8Array;
    /** Immutable bitLen of this BitArray */
    readonly bitLen: number;
    constructor(
    /** Underlying BitArray Uint8Array data */
    uint8Array: Uint8Array, 
    /** Immutable bitLen of this BitArray */
    bitLen: number);
    /** Returns a zero'ed BitArray of `bitLen` */
    static fromBitLen(bitLen: number): BitArray;
    /** Returns a BitArray of `bitLen` with a single bit set to true at position `bitIndex` */
    static fromSingleBit(bitLen: number, bitIndex: number): BitArray;
    /** Returns a BitArray from an array of booleans representation */
    static fromBoolArray(bitBoolArr: boolean[]): BitArray;
    clone(): BitArray;
    /**
     * Get bit value at index `bitIndex`
     */
    get(bitIndex: number): boolean;
    /**
     * Set bit value at index `bitIndex`
     */
    set(bitIndex: number, bit: boolean): void;
    /** Merge two BitArray bitfields with OR. Must have the same bitLen */
    mergeOrWith(bitArray2: BitArray): void;
    /**
     * Returns an array with the indexes which have a bit set to true
     */
    intersectValues<T>(values: ArrayLike<T>): T[];
    /**
     * Returns the positions of all bits that are set to true
     */
    getTrueBitIndexes(): number[];
    /**
     * Return the position of a single bit set.
     * @returns
     *  - number: if there's a single bit set, the number it the single bit set position
     *  - null: if ERROR_MORE_THAN_ONE_BIT_SET or ERROR_NO_BIT_SET
     */
    getSingleTrueBit(): number | null;
    toBoolArray(): boolean[];
}

/**
 * Thin wrapper around BitArray to upstream changes to `tree` on every `this.set()`
 */
declare class BitArrayTreeView extends TreeView<CompositeType<BitArray, unknown, unknown>> implements BitArray {
    readonly type: CompositeType<BitArray, unknown, unknown>;
    protected tree: Tree;
    private readonly bitArray;
    constructor(type: CompositeType<BitArray, unknown, unknown>, tree: Tree);
    get node(): Node_2;
    /** @see BitArray.uint8Array */
    get uint8Array(): Uint8Array;
    /** @see BitArray.bitLen */
    get bitLen(): number;
    /** @see BitArray.get */
    get(bitIndex: number): boolean;
    /** @see BitArray.set */
    set(bitIndex: number, bit: boolean): void;
    /** @see BitArray.mergeOrWith */
    mergeOrWith(bitArray2: BitArray): void;
    /** @see BitArray.intersectValues */
    intersectValues<T>(values: ArrayLike<T>): T[];
    /** @see BitArray.getTrueBitIndexes */
    getTrueBitIndexes(): number[];
    /** @see BitArray.getSingleTrueBit */
    getSingleTrueBit(): number | null;
    /** @see BitArray.toBoolArray */
    toBoolArray(): boolean[];
}

/**
 * Thin wrapper around BitArray to upstream changes after `this.commit()`
 */
declare class BitArrayTreeViewDU extends TreeViewDU<CompositeType<BitArray, unknown, unknown>> implements BitArray {
    readonly type: CompositeType<BitArray, unknown, unknown>;
    protected _rootNode: Node_2;
    /** Cached BitArray instance computed only on demand */
    private _bitArray;
    constructor(type: CompositeType<BitArray, unknown, unknown>, _rootNode: Node_2);
    get node(): Node_2;
    get cache(): unknown;
    /** @see BitArray.uint8Array */
    get uint8Array(): Uint8Array;
    /** @see BitArray.bitLen */
    get bitLen(): number;
    /** Lazily computed bitArray instance */
    private get bitArray();
    commit(hcOffset?: number, hcByLevel?: HashComputationLevel[] | null): void;
    /** @see BitArray.get */
    get(bitIndex: number): boolean;
    /** @see BitArray.set */
    set(bitIndex: number, bit: boolean): void;
    /** @see BitArray.mergeOrWith */
    mergeOrWith(bitArray2: BitArray): void;
    /** @see BitArray.intersectValues */
    intersectValues<T>(values: ArrayLike<T>): T[];
    /** @see BitArray.getTrueBitIndexes */
    getTrueBitIndexes(): number[];
    /** @see BitArray.getSingleTrueBit */
    getSingleTrueBit(): number | null;
    /** @see BitArray.toBoolArray */
    toBoolArray(): boolean[];
    protected clearCache(): void;
}

/**
 * BitArray: ordered array collection of boolean values
 * - Value: `BitArray`, @see BitArray for a justification of its memory efficiency and performance
 * - View: `BitArrayTreeView`
 * - ViewDU: `BitArrayTreeViewDU`
 */
declare abstract class BitArrayType extends CompositeType<BitArray, BitArrayTreeView, BitArrayTreeViewDU> {
    readonly isViewMutable = true;
    getView(tree: Tree): BitArrayTreeView;
    getViewDU(node: Node_2): BitArrayTreeViewDU;
    commitView(view: BitArrayTreeView): Node_2;
    commitViewDU(view: BitArrayTreeViewDU, hcOffset?: number, hcByLevel?: HashComputationLevel[] | null): Node_2;
    cacheOfViewDU(view: BitArrayTreeViewDU): unknown;
    protected getBlocksBytes(value: BitArray): Uint8Array;
    getPropertyGindex(): null;
    getPropertyType(): never;
    getIndexProperty(): never;
    tree_fromProofNode(node: Node_2): {
        node: Node_2;
        done: boolean;
    };
    tree_getLeafGindices(rootGindex: bigint, rootNode?: Node_2): Gindex[];
    abstract tree_getByteLen(node?: Node_2): number;
    fromJson(json: unknown): BitArray;
    toJson(value: BitArray): unknown;
    clone(value: BitArray): BitArray;
    equals(a: BitArray, b: BitArray): boolean;
}

declare interface BitListOptions {
    typeName?: string;
}

/**
 * BitList: ordered variable-length collection of boolean values, limited to N bits
 * - Notation `Bitlist[N]`
 * - Value: `BitArray`, @see BitArray for a justification of its memory efficiency and performance
 * - View: `BitArrayTreeView`
 * - ViewDU: `BitArrayTreeViewDU`
 */
declare class BitListType extends BitArrayType {
    readonly limitBits: number;
    readonly typeName: string;
    readonly depth: number;
    readonly chunkDepth: number;
    readonly fixedSize: null;
    readonly minSize = 1;
    readonly maxSize: number;
    readonly maxChunkCount: number;
    readonly isList = true;
    readonly mixInLengthBlockBytes: Uint8Array<ArrayBuffer>;
    readonly mixInLengthBuffer: Buffer<ArrayBufferLike>;
    constructor(limitBits: number, opts?: BitListOptions);
    static named(limitBits: number, opts: Require<BitListOptions, "typeName">): BitListType;
    defaultValue(): BitArray;
    value_serializedSize(value: BitArray): number;
    value_serializeToBytes(output: ByteViews, offset: number, value: BitArray): number;
    value_deserializeFromBytes(data: ByteViews, start: number, end: number, reuseBytes?: boolean): BitArray;
    tree_serializedSize(node: Node_2): number;
    tree_serializeToBytes(output: ByteViews, offset: number, node: Node_2): number;
    tree_deserializeFromBytes(data: ByteViews, start: number, end: number): Node_2;
    tree_getByteLen(node?: Node_2): number;
    hashTreeRoot(value: BitArray): Uint8Array;
    hashTreeRootInto(value: BitArray, output: Uint8Array, offset: number): void;
    private deserializeUint8ArrayBitListFromBytes;
}

declare interface BitVectorOptions {
    typeName?: string;
}

/**
 * BitVector: ordered fixed-length collection of boolean values, with N bits
 * - Notation: `Bitvector[N]`
 * - Value: `BitArray`, @see BitArray for a justification of its memory efficiency and performance
 * - View: `BitArrayTreeView`
 * - ViewDU: `BitArrayTreeViewDU`
 */
declare class BitVectorType extends BitArrayType {
    readonly lengthBits: number;
    readonly typeName: string;
    readonly chunkCount: number;
    readonly depth: number;
    readonly fixedSize: number;
    readonly minSize: number;
    readonly maxSize: number;
    readonly maxChunkCount: number;
    readonly isList = false;
    /**
     * Mask to check if trailing bits are zero'ed. Mask returns bits that must be zero'ed
     * ```
     * lengthBits % 8 | zeroBitsMask
     * 0              | 0
     * 1              | 11111110
     * 2              | 11111100
     * 7              | 10000000
     * ```
     */
    private readonly zeroBitsMask;
    constructor(lengthBits: number, opts?: BitVectorOptions);
    static named(limitBits: number, opts: Require<BitVectorOptions, "typeName">): BitVectorType;
    defaultValue(): BitArray;
    value_serializedSize(): number;
    value_serializeToBytes(output: ByteViews, offset: number, value: BitArray): number;
    value_deserializeFromBytes(data: ByteViews, start: number, end: number, reuseBytes?: boolean): BitArray;
    tree_serializedSize(): number;
    tree_serializeToBytes(output: ByteViews, offset: number, node: Node_2): number;
    tree_deserializeFromBytes(data: ByteViews, start: number, end: number): Node_2;
    tree_getByteLen(): number;
    private assertValidLength;
}

declare type BlacklistedBlock = {
    root: RootHex;
    slot: Slot_2 | null;
};

declare const BlindedBeaconBlock: ContainerType<{
    slot: UintNumberType;
    proposerIndex: UintNumberType;
    parentRoot: ByteVectorType;
    stateRoot: ByteVectorType;
    body: ContainerType<{
        randaoReveal: ByteVectorType;
        eth1Data: ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
        }>;
        graffiti: ByteVectorType;
        proposerSlashings: ListCompositeType<ContainerType<{
            signedHeader1: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
        }>>;
        attesterSlashings: ListCompositeType<ContainerType<{
            attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
        }>>;
        attestations: ListCompositeType<ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>>;
        deposits: ListCompositeType<ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
            }>;
        }>>;
        voluntaryExits: ListCompositeType<ContainerType<{
            message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
        }>>;
        syncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
        }>;
        executionPayloadHeader: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
        }>;
    }>;
}>;

declare type BlindedBeaconBlock_2 = ValueOf<typeof ssz_4.BlindedBeaconBlock>;

declare const BlindedBeaconBlock_3: ContainerType<{
    slot: UintNumberType;
    proposerIndex: UintNumberType;
    parentRoot: ByteVectorType;
    stateRoot: ByteVectorType;
    body: ContainerType<{
        randaoReveal: ByteVectorType;
        eth1Data: ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
        }>;
        graffiti: ByteVectorType;
        proposerSlashings: ListCompositeType<ContainerType<{
            signedHeader1: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
        }>>;
        attesterSlashings: ListCompositeType<ContainerType<{
            attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
        }>>;
        attestations: ListCompositeType<ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>>;
        deposits: ListCompositeType<ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
            }>;
        }>>;
        voluntaryExits: ListCompositeType<ContainerType<{
            message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
        }>>;
        syncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
        }>;
        executionPayloadHeader: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
        }>;
        blsToExecutionChanges: ListCompositeType<ContainerType<{
            message: ContainerType<{
                validatorIndex: UintNumberType;
                fromBlsPubkey: ByteVectorType;
                toExecutionAddress: ExecutionAddressType;
            }>;
            signature: ByteVectorType;
        }>>;
    }>;
}>;

declare type BlindedBeaconBlock_4 = ValueOf<typeof ssz_5.BlindedBeaconBlock>;

declare const BlindedBeaconBlock_5: ContainerType<{
    slot: UintNumberType;
    proposerIndex: UintNumberType;
    parentRoot: ByteVectorType;
    stateRoot: ByteVectorType;
    body: ContainerType<{
        randaoReveal: ByteVectorType;
        eth1Data: ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
        }>;
        graffiti: ByteVectorType;
        proposerSlashings: ListCompositeType<ContainerType<{
            signedHeader1: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
        }>>;
        attesterSlashings: ListCompositeType<ContainerType<{
            attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
        }>>;
        attestations: ListCompositeType<ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>>;
        deposits: ListCompositeType<ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
            }>;
        }>>;
        voluntaryExits: ListCompositeType<ContainerType<{
            message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
        }>>;
        syncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
        }>;
        executionPayloadHeader: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
        }>;
        blsToExecutionChanges: ListCompositeType<ContainerType<{
            message: ContainerType<{
                validatorIndex: UintNumberType;
                fromBlsPubkey: ByteVectorType;
                toExecutionAddress: ExecutionAddressType;
            }>;
            signature: ByteVectorType;
        }>>;
        blobKzgCommitments: ListCompositeType<ByteVectorType>;
    }>;
}>;

declare type BlindedBeaconBlock_6 = ValueOf<typeof ssz_6.BlindedBeaconBlock>;

declare const BlindedBeaconBlock_7: ContainerType<{
    slot: UintNumberType;
    proposerIndex: UintNumberType;
    parentRoot: ByteVectorType;
    stateRoot: ByteVectorType;
    body: ContainerType<{
        randaoReveal: ByteVectorType;
        eth1Data: ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
        }>;
        graffiti: ByteVectorType;
        proposerSlashings: ListCompositeType<ContainerType<{
            signedHeader1: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
        }>>;
        attesterSlashings: ListCompositeType<ContainerType<{
            attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
        }>>;
        attestations: ListCompositeType<ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
            committeeBits: BitVectorType;
        }>>;
        deposits: ListCompositeType<ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
            }>;
        }>>;
        voluntaryExits: ListCompositeType<ContainerType<{
            message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
        }>>;
        syncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
        }>;
        executionPayloadHeader: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
        }>;
        blsToExecutionChanges: ListCompositeType<ContainerType<{
            message: ContainerType<{
                validatorIndex: UintNumberType;
                fromBlsPubkey: ByteVectorType;
                toExecutionAddress: ExecutionAddressType;
            }>;
            signature: ByteVectorType;
        }>>;
        blobKzgCommitments: ListCompositeType<ByteVectorType>;
        executionRequests: ContainerType<{
            deposits: ListCompositeType<ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                index: UintBigintType;
            }>>;
            withdrawals: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                validatorPubkey: ByteVectorType;
                amount: UintBigintType;
            }>>;
            consolidations: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                sourcePubkey: ByteVectorType;
                targetPubkey: ByteVectorType;
            }>>;
        }>;
    }>;
}>;

declare type BlindedBeaconBlock_8 = ValueOf<typeof ssz_7.BlindedBeaconBlock>;

declare type BlindedBeaconBlock_9<F extends ForkPostBellatrix = ForkPostBellatrix> = TypesByFork[F]["BlindedBeaconBlock"];

declare const BlindedBeaconBlockBody: ContainerType<{
    randaoReveal: ByteVectorType;
    eth1Data: ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
    }>;
    graffiti: ByteVectorType;
    proposerSlashings: ListCompositeType<ContainerType<{
        signedHeader1: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        signedHeader2: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
    }>>;
    attesterSlashings: ListCompositeType<ContainerType<{
        attestation1: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        attestation2: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
    }>>;
    attestations: ListCompositeType<ContainerType<{
        aggregationBits: BitListType;
        data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
        }>;
        signature: ByteVectorType;
    }>>;
    deposits: ListCompositeType<ContainerType<{
        proof: VectorCompositeType<ByteVectorType>;
        data: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
        }>;
    }>>;
    voluntaryExits: ListCompositeType<ContainerType<{
        message: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
        }>;
        signature: ByteVectorType;
    }>>;
    syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
    }>;
    executionPayloadHeader: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactionsRoot: ByteVectorType;
    }>;
}>;

declare type BlindedBeaconBlockBody_2 = ValueOf<typeof ssz_4.BlindedBeaconBlockBody>;

declare const BlindedBeaconBlockBody_3: ContainerType<{
    randaoReveal: ByteVectorType;
    eth1Data: ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
    }>;
    graffiti: ByteVectorType;
    proposerSlashings: ListCompositeType<ContainerType<{
        signedHeader1: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        signedHeader2: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
    }>>;
    attesterSlashings: ListCompositeType<ContainerType<{
        attestation1: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        attestation2: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
    }>>;
    attestations: ListCompositeType<ContainerType<{
        aggregationBits: BitListType;
        data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
        }>;
        signature: ByteVectorType;
    }>>;
    deposits: ListCompositeType<ContainerType<{
        proof: VectorCompositeType<ByteVectorType>;
        data: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
        }>;
    }>>;
    voluntaryExits: ListCompositeType<ContainerType<{
        message: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
        }>;
        signature: ByteVectorType;
    }>>;
    syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
    }>;
    executionPayloadHeader: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactionsRoot: ByteVectorType;
        withdrawalsRoot: ByteVectorType;
    }>;
    blsToExecutionChanges: ListCompositeType<ContainerType<{
        message: ContainerType<{
            validatorIndex: UintNumberType;
            fromBlsPubkey: ByteVectorType;
            toExecutionAddress: ExecutionAddressType;
        }>;
        signature: ByteVectorType;
    }>>;
}>;

declare type BlindedBeaconBlockBody_4 = ValueOf<typeof ssz_5.BlindedBeaconBlockBody>;

declare const BlindedBeaconBlockBody_5: ContainerType<{
    randaoReveal: ByteVectorType;
    eth1Data: ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
    }>;
    graffiti: ByteVectorType;
    proposerSlashings: ListCompositeType<ContainerType<{
        signedHeader1: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        signedHeader2: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
    }>>;
    attesterSlashings: ListCompositeType<ContainerType<{
        attestation1: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        attestation2: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
    }>>;
    attestations: ListCompositeType<ContainerType<{
        aggregationBits: BitListType;
        data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
        }>;
        signature: ByteVectorType;
    }>>;
    deposits: ListCompositeType<ContainerType<{
        proof: VectorCompositeType<ByteVectorType>;
        data: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
        }>;
    }>>;
    voluntaryExits: ListCompositeType<ContainerType<{
        message: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
        }>;
        signature: ByteVectorType;
    }>>;
    syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
    }>;
    executionPayloadHeader: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactionsRoot: ByteVectorType;
        withdrawalsRoot: ByteVectorType;
        blobGasUsed: UintBigintType;
        excessBlobGas: UintBigintType;
    }>;
    blsToExecutionChanges: ListCompositeType<ContainerType<{
        message: ContainerType<{
            validatorIndex: UintNumberType;
            fromBlsPubkey: ByteVectorType;
            toExecutionAddress: ExecutionAddressType;
        }>;
        signature: ByteVectorType;
    }>>;
    blobKzgCommitments: ListCompositeType<ByteVectorType>;
}>;

declare type BlindedBeaconBlockBody_6 = ValueOf<typeof ssz_6.BlindedBeaconBlockBody>;

declare const BlindedBeaconBlockBody_7: ContainerType<{
    randaoReveal: ByteVectorType;
    eth1Data: ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
    }>;
    graffiti: ByteVectorType;
    proposerSlashings: ListCompositeType<ContainerType<{
        signedHeader1: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        signedHeader2: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
    }>>;
    attesterSlashings: ListCompositeType<ContainerType<{
        attestation1: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        attestation2: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
    }>>;
    attestations: ListCompositeType<ContainerType<{
        aggregationBits: BitListType;
        data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
        }>;
        signature: ByteVectorType;
        committeeBits: BitVectorType;
    }>>;
    deposits: ListCompositeType<ContainerType<{
        proof: VectorCompositeType<ByteVectorType>;
        data: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
        }>;
    }>>;
    voluntaryExits: ListCompositeType<ContainerType<{
        message: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
        }>;
        signature: ByteVectorType;
    }>>;
    syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
    }>;
    executionPayloadHeader: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactionsRoot: ByteVectorType;
        withdrawalsRoot: ByteVectorType;
        blobGasUsed: UintBigintType;
        excessBlobGas: UintBigintType;
    }>;
    blsToExecutionChanges: ListCompositeType<ContainerType<{
        message: ContainerType<{
            validatorIndex: UintNumberType;
            fromBlsPubkey: ByteVectorType;
            toExecutionAddress: ExecutionAddressType;
        }>;
        signature: ByteVectorType;
    }>>;
    blobKzgCommitments: ListCompositeType<ByteVectorType>;
    executionRequests: ContainerType<{
        deposits: ListCompositeType<ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            index: UintBigintType;
        }>>;
        withdrawals: ListCompositeType<ContainerType<{
            sourceAddress: ExecutionAddressType;
            validatorPubkey: ByteVectorType;
            amount: UintBigintType;
        }>>;
        consolidations: ListCompositeType<ContainerType<{
            sourceAddress: ExecutionAddressType;
            sourcePubkey: ByteVectorType;
            targetPubkey: ByteVectorType;
        }>>;
    }>;
}>;

declare type BlindedBeaconBlockBody_8 = ValueOf<typeof ssz_7.BlindedBeaconBlockBody>;

declare const BlindedBlob: ByteVectorType;

declare const BlindedBlobs: ListCompositeType<ByteVectorType>;

declare const Blob_2: ByteVectorType;

declare type Blob_3 = ValueOf<typeof ssz_6.Blob>;

declare const Blob_4: ByteVectorType;

declare type Blob_5 = ValueOf<typeof ssz_8.Blob>;

declare type BlobAndProof = {
    blob: Blob_3;
    proof: KZGProof;
};

declare type BlobAndProofV2 = {
    blob: Blob_5;
    proofs: KZGProof_3[];
};

declare const BlobIdentifier: ContainerType<{
    blockRoot: ByteVectorType;
    index: UintNumberType;
}>;

declare type BlobIdentifier_2 = ValueOf<typeof ssz_6.BlobIdentifier>;

declare const BlobIndex: UintNumberType;

declare const BlobKzgCommitments: ListCompositeType<ByteVectorType>;

declare type BlobKzgCommitments_2 = ValueOf<typeof ssz_6.BlobKzgCommitments>;

declare type BlobParameters = {
    epoch: Epoch;
    maxBlobsPerBlock: UintNum64_2;
};

declare const Blobs: ListCompositeType<ByteVectorType>;

declare type Blobs_2 = ValueOf<typeof ssz_6.Blobs>;

declare const BlobsBundle: ContainerType<{
    commitments: ListCompositeType<ByteVectorType>;
    proofs: ListCompositeType<ByteVectorType>;
    blobs: ListCompositeType<ByteVectorType>;
}>;

declare type BlobsBundle_2 = ValueOf<typeof ssz_6.BlobsBundle>;

declare const BlobsBundle_3: ContainerType<{
    commitments: ListCompositeType<ByteVectorType>;
    proofs: ListCompositeType<ByteVectorType>;
    blobs: ListCompositeType<ByteVectorType>;
}>;

declare type BlobsBundle_4 = ValueOf<typeof ssz_8.BlobsBundle>;

declare type BlobSchedule = BlobScheduleEntry[];

declare type BlobScheduleEntry = {
    EPOCH: number;
    MAX_BLOBS_PER_BLOCK: number;
};

declare const BlobSidecar: ContainerType<{
    index: UintNumberType;
    blob: ByteVectorType;
    kzgCommitment: ByteVectorType;
    kzgProof: ByteVectorType;
    signedBlockHeader: ContainerType<{
        message: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        signature: ByteVectorType;
    }>;
    kzgCommitmentInclusionProof: VectorCompositeType<ByteVectorType>;
}>;

declare type BlobSidecar_2 = ValueOf<typeof ssz_6.BlobSidecar>;

declare const BlobSidecars: ListCompositeType<ContainerType<{
    index: UintNumberType;
    blob: ByteVectorType;
    kzgCommitment: ByteVectorType;
    kzgProof: ByteVectorType;
    signedBlockHeader: ContainerType<{
        message: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        signature: ByteVectorType;
    }>;
    kzgCommitmentInclusionProof: VectorCompositeType<ByteVectorType>;
}>>;

declare type BlobSidecars_2 = ValueOf<typeof ssz_6.BlobSidecars>;

declare const BlobSidecarsByRangeRequest: ContainerType<{
    startSlot: UintNumberType;
    count: UintNumberType;
}>;

declare type BlobSidecarsByRangeRequest_2 = ValueOf<typeof ssz_6.BlobSidecarsByRangeRequest>;

declare type BlobSidecarSSE = ValueOf<typeof blobSidecarSSE>;

declare const blobSidecarSSE: ContainerType<{
    blockRoot: StringType<string>;
    index: UintNumberType;
    slot: UintNumberType;
    kzgCommitment: StringType<string>;
    versionedHash: StringType<string>;
}>;

declare namespace block {
    export {
        getDefinitions,
        BlockHeaderResponseType,
        BlockHeadersResponseType,
        RootResponseType,
        BlockHeaderResponse,
        BlockHeadersResponse,
        RootResponse,
        BlockId,
        BlockArgs,
        BroadcastValidation,
        Endpoints_3 as Endpoints
    }
}

declare const BlockAccessList: ByteListType;

declare type BlockAccessList_2 = ValueOf<typeof ssz_9.BlockAccessList>;

declare type BlockArgs = {
    /**
     * Block identifier.
     * Can be one of: "head" (canonical head in node's view), "genesis", "finalized", "justified", \<slot\>, \<hex encoded blockRoot with 0x prefix\>.
     */
    blockId: BlockId;
};

declare const BlockContents: ContainerType<{
    block: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        body: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
            }>>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            executionPayload: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactions: ListCompositeType<ByteListType>;
                withdrawals: ListCompositeType<ContainerType<{
                    index: UintNumberType;
                    validatorIndex: UintNumberType;
                    address: ExecutionAddressType;
                    amount: UintBigintType;
                }>>;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            blsToExecutionChanges: ListCompositeType<ContainerType<{
                message: ContainerType<{
                    validatorIndex: UintNumberType;
                    fromBlsPubkey: ByteVectorType;
                    toExecutionAddress: ExecutionAddressType;
                }>;
                signature: ByteVectorType;
            }>>;
            blobKzgCommitments: ListCompositeType<ByteVectorType>;
        }>;
    }>;
    kzgProofs: ListCompositeType<ByteVectorType>;
    blobs: ListCompositeType<ByteVectorType>;
}>;

declare type BlockContents_2 = ValueOf<typeof ssz_6.BlockContents>;

declare const BlockContents_3: ContainerType<{
    block: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        body: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
                committeeBits: BitVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
            }>>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            executionPayload: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactions: ListCompositeType<ByteListType>;
                withdrawals: ListCompositeType<ContainerType<{
                    index: UintNumberType;
                    validatorIndex: UintNumberType;
                    address: ExecutionAddressType;
                    amount: UintBigintType;
                }>>;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            blsToExecutionChanges: ListCompositeType<ContainerType<{
                message: ContainerType<{
                    validatorIndex: UintNumberType;
                    fromBlsPubkey: ByteVectorType;
                    toExecutionAddress: ExecutionAddressType;
                }>;
                signature: ByteVectorType;
            }>>;
            blobKzgCommitments: ListCompositeType<ByteVectorType>;
            executionRequests: ContainerType<{
                deposits: ListCompositeType<ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    index: UintBigintType;
                }>>;
                withdrawals: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    validatorPubkey: ByteVectorType;
                    amount: UintBigintType;
                }>>;
                consolidations: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    sourcePubkey: ByteVectorType;
                    targetPubkey: ByteVectorType;
                }>>;
            }>;
        }>;
    }>;
    kzgProofs: ListCompositeType<ByteVectorType>;
    blobs: ListCompositeType<ByteVectorType>;
}>;

declare type BlockContents_4 = ValueOf<typeof ssz_7.BlockContents>;

declare const BlockContents_5: ContainerType<{
    block: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        body: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
                committeeBits: BitVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
            }>>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            executionPayload: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactions: ListCompositeType<ByteListType>;
                withdrawals: ListCompositeType<ContainerType<{
                    index: UintNumberType;
                    validatorIndex: UintNumberType;
                    address: ExecutionAddressType;
                    amount: UintBigintType;
                }>>;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            blsToExecutionChanges: ListCompositeType<ContainerType<{
                message: ContainerType<{
                    validatorIndex: UintNumberType;
                    fromBlsPubkey: ByteVectorType;
                    toExecutionAddress: ExecutionAddressType;
                }>;
                signature: ByteVectorType;
            }>>;
            blobKzgCommitments: ListCompositeType<ByteVectorType>;
            executionRequests: ContainerType<{
                deposits: ListCompositeType<ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    index: UintBigintType;
                }>>;
                withdrawals: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    validatorPubkey: ByteVectorType;
                    amount: UintBigintType;
                }>>;
                consolidations: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    sourcePubkey: ByteVectorType;
                    targetPubkey: ByteVectorType;
                }>>;
            }>;
        }>;
    }>;
    kzgProofs: ListCompositeType<ByteVectorType>;
    blobs: ListCompositeType<ByteVectorType>;
}>;

declare type BlockContents_6 = ValueOf<typeof ssz_8.BlockContents>;

declare type BlockContents_7<F extends ForkAll = ForkAll> = TypesByFork[F]["BlockContents"];

declare type BlockHeaderResponse = ValueOf<typeof BlockHeaderResponseType>;

declare const BlockHeaderResponseType: ContainerType<{
    root: ByteVectorType;
    canonical: BooleanType;
    header: ContainerType<{
        message: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        signature: ByteVectorType;
    }>;
}>;

declare type BlockHeadersResponse = ValueOf<typeof BlockHeadersResponseType>;

declare const BlockHeadersResponseType: ListCompositeType<ContainerType<{
    root: ByteVectorType;
    canonical: BooleanType;
    header: ContainerType<{
        message: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        signature: ByteVectorType;
    }>;
}>>;

declare type BlockId = RootHex | Slot_2 | "head" | "genesis" | "finalized" | "justified";

declare type BlockProcessorQueueItem = {
    blockSlots: Slot_2[];
    jobOpts: Record<string, string | number | boolean | undefined>;
    addedTimeMs: number;
};

/**
 * Rewards info for a single block. Every reward value is in Gwei.
 */
declare type BlockRewards = ValueOf<typeof BlockRewardsType>;

declare const BlockRewardsType: ContainerType<{
    /** Proposer of the block, the proposer index who receives these rewards */
    proposerIndex: UintNumberType;
    /** Total block reward, equal to attestations + sync_aggregate + proposer_slashings + attester_slashings */
    total: UintNumberType;
    /** Block reward component due to included attestations */
    attestations: UintNumberType;
    /** Block reward component due to included sync_aggregate */
    syncAggregate: UintNumberType;
    /** Block reward component due to included proposer_slashings */
    proposerSlashings: UintNumberType;
    /** Block reward component due to included attester_slashings */
    attesterSlashings: UintNumberType;
}>;

declare const BLSFieldElement: ByteVectorType;

declare type BLSFieldElement_2 = ValueOf<typeof ssz_6.BLSFieldElement>;

declare const BLSPubkey: ByteVectorType;

declare const BLSSignature: ByteVectorType;

declare type BLSSignature_2 = Bytes96_2;

declare const BLSToExecutionChange: ContainerType<{
    validatorIndex: UintNumberType;
    fromBlsPubkey: ByteVectorType;
    toExecutionAddress: ExecutionAddressType;
}>;

declare type BLSToExecutionChange_2 = ValueOf<typeof ssz_5.BLSToExecutionChange>;

declare const BLSToExecutionChanges: ListCompositeType<ContainerType<{
    message: ContainerType<{
        validatorIndex: UintNumberType;
        fromBlsPubkey: ByteVectorType;
        toExecutionAddress: ExecutionAddressType;
    }>;
    signature: ByteVectorType;
}>>;

declare type BLSToExecutionChanges_2 = ValueOf<typeof ssz_5.BLSToExecutionChanges>;

declare const Boolean_2: BooleanType;

declare interface BooleanOpts {
    typeName?: string;
}

/**
 * Boolean: True or False
 * - Notation: `boolean`
 */
declare class BooleanType extends BasicType<boolean> {
    readonly typeName: string;
    readonly byteLength = 1;
    readonly itemsPerChunk = 32;
    readonly fixedSize = 1;
    readonly minSize = 1;
    readonly maxSize = 1;
    constructor(opts?: BooleanOpts);
    static named(opts: Require<BooleanOpts, "typeName">): BooleanType;
    defaultValue(): boolean;
    value_serializeToBytes(output: ByteViews, offset: number, value: boolean): number;
    value_deserializeFromBytes(data: ByteViews, start: number, end: number): boolean;
    tree_serializeToBytes(output: ByteViews, offset: number, node: Node_2): number;
    tree_deserializeFromBytes(data: ByteViews, start: number, end: number): Node_2;
    tree_getFromNode(leafNode: LeafNode): boolean;
    tree_setToNode(leafNode: LeafNode, value: boolean): void;
    tree_getFromPackedNode(leafNode: LeafNode, index: number): boolean;
    tree_setToPackedNode(leafNode: LeafNode, index: number, value: boolean): void;
    fromJson(json: unknown): boolean;
    toJson(value: boolean): unknown;
}

declare enum BroadcastValidation {
    /**
     NOTE: The value `none` is not part of the spec.

     In case a node is configured only with the unknownBlockSync, it needs to know the unknown parent blocks on the network
     to initiate the syncing process. Such cases can be covered only if we publish blocks and make sure no gossip validation
     is performed on those. But this behavior is not the default.
     */
    none = "none",
    gossip = "gossip",
    consensus = "consensus",
    consensusAndEquivocation = "consensus_and_equivocation"
}

declare type Builder = ValueOf<typeof ssz_9.Builder>;

declare const Builder_2: ContainerType<{
    pubkey: ByteVectorType;
    version: UintNumberType;
    executionAddress: ExecutionAddressType;
    balance: UintNumberType;
    depositEpoch: UintNumberType;
    withdrawableEpoch: UintNumberType;
}>;

declare const BuilderBid: ContainerType<{
    header: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactionsRoot: ByteVectorType;
    }>;
    value: UintBigintType;
    pubkey: ByteVectorType;
}>;

declare type BuilderBid_2 = ValueOf<typeof ssz_4.BuilderBid>;

declare const BuilderBid_3: ContainerType<{
    header: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactionsRoot: ByteVectorType;
        withdrawalsRoot: ByteVectorType;
    }>;
    value: UintBigintType;
    pubkey: ByteVectorType;
}>;

declare type BuilderBid_4 = ValueOf<typeof ssz_5.BuilderBid>;

declare const BuilderBid_5: ContainerType<{
    header: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactionsRoot: ByteVectorType;
        withdrawalsRoot: ByteVectorType;
        blobGasUsed: UintBigintType;
        excessBlobGas: UintBigintType;
    }>;
    blobKzgCommitments: ListCompositeType<ByteVectorType>;
    value: UintBigintType;
    pubkey: ByteVectorType;
}>;

declare type BuilderBid_6 = ValueOf<typeof ssz_6.BuilderBid>;

declare const BuilderBid_7: ContainerType<{
    header: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactionsRoot: ByteVectorType;
        withdrawalsRoot: ByteVectorType;
        blobGasUsed: UintBigintType;
        excessBlobGas: UintBigintType;
    }>;
    blobKzgCommitments: ListCompositeType<ByteVectorType>;
    executionRequests: ContainerType<{
        deposits: ListCompositeType<ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            index: UintBigintType;
        }>>;
        withdrawals: ListCompositeType<ContainerType<{
            sourceAddress: ExecutionAddressType;
            validatorPubkey: ByteVectorType;
            amount: UintBigintType;
        }>>;
        consolidations: ListCompositeType<ContainerType<{
            sourceAddress: ExecutionAddressType;
            sourcePubkey: ByteVectorType;
            targetPubkey: ByteVectorType;
        }>>;
    }>;
    value: UintBigintType;
    pubkey: ByteVectorType;
}>;

declare type BuilderBid_8 = ValueOf<typeof ssz_7.BuilderBid>;

declare const BuilderIndex: UintNumberType;

declare type BuilderIndex_2 = UintNumInf64;

declare const BuilderPendingPayment: ContainerType<{
    weight: UintNumberType;
    withdrawal: ContainerType<{
        feeRecipient: ExecutionAddressType;
        amount: UintNumberType;
        builderIndex: UintNumberType;
    }>;
}>;

declare type BuilderPendingPayment_2 = ValueOf<typeof ssz_9.BuilderPendingPayment>;

declare const BuilderPendingWithdrawal: ContainerType<{
    feeRecipient: ExecutionAddressType;
    amount: UintNumberType;
    builderIndex: UintNumberType;
}>;

declare type BuilderPendingWithdrawal_2 = ValueOf<typeof ssz_9.BuilderPendingWithdrawal>;

declare enum BuilderSelection {
    Default = "default",
    BuilderAlways = "builderalways",
    ExecutionAlways = "executionalways",
    MaxProfit = "maxprofit",
    /** Only activate builder flow for DVT block proposal protocols */
    BuilderOnly = "builderonly",
    /** Only builds execution block*/
    ExecutionOnly = "executiononly"
}

declare const Byte: UintNumberType;

declare type ByteArray = Uint8Array;

/**
 * ByteArray: ordered array collection of byte values
 * - Value: `Uint8Array`
 * - View: `Uint8Array`
 * - ViewDU: `Uint8Array`
 *
 * ByteArray is an immutable value which is represented by a Uint8Array for memory efficiency and performance.
 * Note: Consumers of this type MUST never mutate the `Uint8Array` representation of a ByteArray.
 */
declare abstract class ByteArrayType extends CompositeType<ByteArray, ByteArray, ByteArray> {
    readonly isViewMutable = false;
    defaultValue(): ByteArray;
    getView(tree: Tree): ByteArray;
    getViewDU(node: Node_2): ByteArray;
    commitView(view: ByteArray): Node_2;
    commitViewDU(view: ByteArray, hcOffset?: number, hcByLevel?: HashComputationLevel[] | null): Node_2;
    cacheOfViewDU(): unknown;
    toView(value: ByteArray): ByteArray;
    toViewDU(value: ByteArray): ByteArray;
    value_serializeToBytes(output: ByteViews, offset: number, value: ByteArray): number;
    value_deserializeFromBytes(data: ByteViews, start: number, end: number, reuseBytes?: boolean): ByteArray;
    value_toTree(value: ByteArray): Node_2;
    protected getBlocksBytes(value: ByteArray): Uint8Array;
    getPropertyGindex(): null;
    getPropertyType(): never;
    getIndexProperty(): never;
    tree_fromProofNode(node: Node_2): {
        node: Node_2;
        done: boolean;
    };
    tree_getLeafGindices(rootGindex: bigint, rootNode?: Node_2): Gindex[];
    abstract tree_getByteLen(node?: Node_2): number;
    fromJson(json: unknown): ByteArray;
    toJson(value: ByteArray): unknown;
    clone(value: ByteArray): ByteArray;
    equals(a: Uint8Array, b: Uint8Array): boolean;
    protected abstract assertValidSize(size: number): void;
}

declare interface ByteListOptions {
    typeName?: string;
}

/**
 * ByteList: Immutable alias of List[byte, N]
 * - Notation: `ByteList[N]`
 * - Value: `Uint8Array`
 * - View: `Uint8Array`
 * - ViewDU: `Uint8Array`
 *
 * ByteList is an immutable value which is represented by a Uint8Array for memory efficiency and performance.
 * Note: Consumers of this type MUST never mutate the `Uint8Array` representation of a ByteList.
 *
 * For a `ByteListType` with mutability, use `ListBasicType(byteType)`
 */
declare class ByteListType extends ByteArrayType {
    readonly limitBytes: number;
    readonly typeName: string;
    readonly depth: number;
    readonly chunkDepth: number;
    readonly fixedSize: null;
    readonly minSize: number;
    readonly maxSize: number;
    readonly maxChunkCount: number;
    readonly isList = true;
    readonly blockArray: Uint8Array[];
    private blockBytesLen;
    readonly mixInLengthBlockBytes: Uint8Array<ArrayBuffer>;
    readonly mixInLengthBuffer: Buffer<ArrayBufferLike>;
    constructor(limitBytes: number, opts?: ByteListOptions);
    static named(limitBits: number, opts: Require<ByteListOptions, "typeName">): ByteListType;
    value_serializedSize(value: Uint8Array): number;
    tree_serializedSize(node: Node_2): number;
    tree_serializeToBytes(output: ByteViews, offset: number, node: Node_2): number;
    tree_deserializeFromBytes(data: ByteViews, start: number, end: number): Node_2;
    tree_getByteLen(node?: Node_2): number;
    hashTreeRoot(value: ByteArray): Uint8Array;
    /**
     * Use  merkleizeBlockArray() instead of merkleizeBlocksBytes() to avoid big memory allocation
     */
    hashTreeRootInto(value: Uint8Array, output: Uint8Array, offset: number): void;
    protected assertValidSize(size: number): void;
}

declare const Bytes20: ByteVectorType;

declare const Bytes32: ByteVectorType;

declare type Bytes32_2 = ValueOf<typeof ssz.Bytes32>;

declare const Bytes4: ByteVectorType;

declare const Bytes48: ByteVectorType;

declare type Bytes4_2 = ValueOf<typeof ssz.Bytes4>;

declare const Bytes8: ByteVectorType;

declare const Bytes96: ByteVectorType;

declare type Bytes96_2 = ValueOf<typeof ssz.Bytes96>;

declare type BytesRange = {
    start: number;
    end: number;
};

declare type ByteVector = Uint8Array;

declare interface ByteVectorOptions {
    typeName?: string;
}

/**
 * ByteVector: Immutable alias of Vector[byte, N]
 * - Notation: `ByteVector[N]`
 * - Value: `Uint8Array`
 * - View: `Uint8Array`
 * - ViewDU: `Uint8Array`
 *
 * ByteVector is an immutable value which is represented by a Uint8Array for memory efficiency and performance.
 * Note: Consumers of this type MUST never mutate the `Uint8Array` representation of a ByteVector.
 *
 * For a `ByteVectorType` with mutability, use `VectorBasicType(byteType)`
 */
declare class ByteVectorType extends ByteArrayType {
    readonly lengthBytes: number;
    readonly typeName: string;
    readonly depth: number;
    readonly chunkDepth: number;
    readonly fixedSize: number;
    readonly minSize: number;
    readonly maxSize: number;
    readonly maxChunkCount: number;
    readonly isList = false;
    constructor(lengthBytes: number, opts?: ByteVectorOptions);
    static named(limitBits: number, opts: Require<ByteVectorOptions, "typeName">): ByteVectorType;
    value_serializedSize(): number;
    tree_serializedSize(): number;
    tree_serializeToBytes(output: ByteViews, offset: number, node: Node_2): number;
    tree_deserializeFromBytes(data: ByteViews, start: number, end: number): Node_2;
    tree_getByteLen(): number;
    protected assertValidSize(size: number): void;
}

/**
 * Provide two views recursively to any deserialization operation:
 * - For uint it's x10 times faster to read and write with DataView
 * - For ByteArray and BitArray it's x10 times faster to slice a Uint8Array than an ArrayBuffer
 *
 * Providing both allows to optimize for both cases with the tiny overhead of creating a new view.
 */
declare type ByteViews = {
    uint8Array: Uint8Array;
    dataView: DataView;
};

declare interface CachedGenesis extends ForkDigestContext {
    /**
     * Return the signature domain (fork version concatenated with domain type) of a message.
     *
     * Note: The configured fork schedule is always used rather than on-chain fork schedule.
     */
    getDomain(domainSlot: Slot_2, domainType: DomainType_2, messageSlot?: Slot_2): Uint8Array;
    /**
     * Return the signature domain corresponding to a particular fork version
     */
    getDomainAtFork(forkName: ForkName, domainType: DomainType_2): Uint8Array;
    getDomainForVoluntaryExit(stateSlot: Slot_2, messageSlot?: Slot_2): Uint8Array;
    readonly genesisValidatorsRoot: Root_2;
}

declare type CasingMap<Fields extends Record<string, unknown>> = Partial<{
    [K in keyof Fields]: string;
}>;

declare const Cell: ByteVectorType;

declare type Cell_2 = ValueOf<typeof ssz_8.Cell>;

/**
 * Run-time chain configuration
 */
declare type ChainConfig = {
    PRESET_BASE: PresetName;
    /**
     * Free-form short name of the network that this configuration applies to - known
     * canonical network names include:
     * * 'mainnet' - there can be only one
     * * 'hoodi' - testnet
     * Must match the regex: [a-z0-9\-]
     */
    CONFIG_NAME: string;
    /** @deprecated All networks have completed the merge transition */
    TERMINAL_TOTAL_DIFFICULTY: bigint;
    /** @deprecated All networks have completed the merge transition */
    TERMINAL_BLOCK_HASH: Uint8Array;
    /** @deprecated All networks have completed the merge transition */
    TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH: number;
    MIN_GENESIS_ACTIVE_VALIDATOR_COUNT: number;
    MIN_GENESIS_TIME: number;
    GENESIS_FORK_VERSION: Uint8Array;
    GENESIS_DELAY: number;
    ALTAIR_FORK_VERSION: Uint8Array;
    ALTAIR_FORK_EPOCH: number;
    BELLATRIX_FORK_VERSION: Uint8Array;
    BELLATRIX_FORK_EPOCH: number;
    CAPELLA_FORK_VERSION: Uint8Array;
    CAPELLA_FORK_EPOCH: number;
    DENEB_FORK_VERSION: Uint8Array;
    DENEB_FORK_EPOCH: number;
    ELECTRA_FORK_VERSION: Uint8Array;
    ELECTRA_FORK_EPOCH: number;
    FULU_FORK_VERSION: Uint8Array;
    FULU_FORK_EPOCH: number;
    GLOAS_FORK_VERSION: Uint8Array;
    GLOAS_FORK_EPOCH: number;
    /** @deprecated Use `SLOT_DURATION_MS` instead. */
    SECONDS_PER_SLOT: number;
    SLOT_DURATION_MS: number;
    SECONDS_PER_ETH1_BLOCK: number;
    MIN_VALIDATOR_WITHDRAWABILITY_DELAY: number;
    MIN_BUILDER_WITHDRAWABILITY_DELAY: number;
    SHARD_COMMITTEE_PERIOD: number;
    ETH1_FOLLOW_DISTANCE: number;
    PROPOSER_REORG_CUTOFF_BPS: number;
    ATTESTATION_DUE_BPS: number;
    AGGREGATE_DUE_BPS: number;
    SYNC_MESSAGE_DUE_BPS: number;
    CONTRIBUTION_DUE_BPS: number;
    ATTESTATION_DUE_BPS_GLOAS: number;
    AGGREGATE_DUE_BPS_GLOAS: number;
    SYNC_MESSAGE_DUE_BPS_GLOAS: number;
    CONTRIBUTION_DUE_BPS_GLOAS: number;
    PAYLOAD_ATTESTATION_DUE_BPS: number;
    INACTIVITY_SCORE_BIAS: number;
    INACTIVITY_SCORE_RECOVERY_RATE: number;
    EJECTION_BALANCE: number;
    MIN_PER_EPOCH_CHURN_LIMIT: number;
    MAX_PER_EPOCH_ACTIVATION_CHURN_LIMIT: number;
    CHURN_LIMIT_QUOTIENT: number;
    MAX_PER_EPOCH_ACTIVATION_EXIT_CHURN_LIMIT: number;
    MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA: number;
    CHURN_LIMIT_QUOTIENT_GLOAS: number;
    CONSOLIDATION_CHURN_LIMIT_QUOTIENT: number;
    MAX_PER_EPOCH_ACTIVATION_CHURN_LIMIT_GLOAS: number;
    PROPOSER_SCORE_BOOST: number;
    REORG_HEAD_WEIGHT_THRESHOLD: number;
    REORG_PARENT_WEIGHT_THRESHOLD: number;
    REORG_MAX_EPOCHS_SINCE_FINALIZATION: number;
    DEPOSIT_CHAIN_ID: number;
    DEPOSIT_NETWORK_ID: number;
    DEPOSIT_CONTRACT_ADDRESS: Uint8Array;
    MAX_PAYLOAD_SIZE: number;
    MAX_REQUEST_BLOCKS: number;
    EPOCHS_PER_SUBNET_SUBSCRIPTION: number;
    MIN_EPOCHS_FOR_BLOCK_REQUESTS: number;
    ATTESTATION_PROPAGATION_SLOT_RANGE: number;
    MAXIMUM_GOSSIP_CLOCK_DISPARITY: number;
    MESSAGE_DOMAIN_INVALID_SNAPPY: Uint8Array;
    MESSAGE_DOMAIN_VALID_SNAPPY: Uint8Array;
    SUBNETS_PER_NODE: number;
    MAX_REQUEST_BLOCKS_DENEB: number;
    MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS: number;
    MIN_EPOCHS_FOR_DATA_COLUMN_SIDECARS_REQUESTS: number;
    BLOB_SIDECAR_SUBNET_COUNT: number;
    MAX_BLOBS_PER_BLOCK: number;
    MAX_REQUEST_BLOB_SIDECARS: number;
    BLOB_SIDECAR_SUBNET_COUNT_ELECTRA: number;
    DATA_COLUMN_SIDECAR_SUBNET_COUNT: number;
    MAX_BLOBS_PER_BLOCK_ELECTRA: number;
    MAX_REQUEST_BLOB_SIDECARS_ELECTRA: number;
    MAX_REQUEST_DATA_COLUMN_SIDECARS: number;
    NUMBER_OF_CUSTODY_GROUPS: number;
    SAMPLES_PER_SLOT: number;
    CUSTODY_REQUIREMENT: number;
    VALIDATOR_CUSTODY_REQUIREMENT: number;
    BALANCE_PER_ADDITIONAL_CUSTODY_GROUP: number;
    MAX_REQUEST_PAYLOADS: number;
    BLOB_SCHEDULE: BlobSchedule;
};

/**
 * Chain run-time configuration with additional fork schedule helpers
 */
declare type ChainForkConfig = ChainConfig & ForkConfig;

/** Checkpoint where epoch is bounded by the clock, and values above it are invalid */
declare const Checkpoint: ContainerType<{
    epoch: UintNumberType;
    root: ByteVectorType;
}>;

declare type Checkpoint_2 = ValueOf<typeof ssz_2.Checkpoint>;

/** Checkpoint where epoch is NOT bounded by the clock, so must be a bigint */
declare const CheckpointBigint: ContainerType<{
    epoch: UintBigintType;
    root: ByteVectorType;
}>;

/**
 * Split an inclusive range into a sequence of contiguous inclusive ranges
 * ```
 * [[a,b], [c,d] ... Sn] = chunkifyInclusiveRange([a,z], n)
 * // where
 * [a,z] = [a,b] U [c,d] U ... U Sn
 * ```
 * @param from range start inclusive
 * @param to range end inclusive
 * @param chunks Maximum number of chunks, if range is big enough
 */
declare function chunkifyInclusiveRange(from: number, to: number, itemsPerChunk: number): number[][];

/**
 * Client code as defined in https://github.com/ethereum/execution-apis/blob/dc4dbca37ef8697d782f431af19120beaf5517f5/src/engine/identification.md#clientcode
 * ClientCode.XX is dedicated to other clients which do not have their own code
 */
declare enum ClientCode {
    BU = "BU",
    EJ = "EJ",
    EG = "EG",
    GE = "GE",
    GR = "GR",
    LH = "LH",
    LS = "LS",
    NM = "NM",
    NB = "NB",
    TE = "TE",
    TK = "TK",
    PM = "PM",
    RH = "RH",
    XX = "XX"
}

/**
 * A structure which uniquely identifies a client implementation and its version.
 * Mirrors the client version specification in the Engine API.
 * https://github.com/ethereum/execution-apis/blob/dc4dbca37ef8697d782f431af19120beaf5517f5/src/engine/identification.md
 */
declare type ClientVersion = {
    code: ClientCode;
    name: string;
    version: string;
    commit: string;
};

declare const ColumnIndex: UintNumberType;

declare const CommitteeAssignment: ContainerType<{
    validators: ListBasicType<UintNumberType>;
    committeeIndex: UintNumberType;
    slot: UintNumberType;
}>;

declare type CommitteeAssignment_2 = ValueOf<typeof ssz_2.CommitteeAssignment>;

declare const CommitteeBits: BitListType;

declare const CommitteeBits_2: BitVectorType;

/**
 * Use JS Number for performance, values must be limited to 2**52-1.
 * CommitteeIndex is bounded by the max possible number of committees which is bounded by `VALIDATOR_REGISTRY_LIMIT`
 */
declare const CommitteeIndex: UintNumberType;

declare type CommitteeIndex_2 = UintNum64_2;

declare const CommitteeIndices: ListBasicType<UintNumberType>;

declare const CommonExecutionPayloadType: ContainerType<{
    parentHash: ByteVectorType;
    feeRecipient: ExecutionAddressType;
    stateRoot: ByteVectorType;
    receiptsRoot: ByteVectorType;
    logsBloom: ByteVectorType;
    prevRandao: ByteVectorType;
    blockNumber: UintNumberType;
    gasLimit: UintNumberType;
    gasUsed: UintNumberType;
    timestamp: UintNumberType;
    extraData: ByteListType;
    baseFeePerGas: UintBigintType;
    blockHash: ByteVectorType;
}>;

declare interface CompactMultiProof {
    type: ProofType.compactMulti;
    leaves: Uint8Array[];
    descriptor: Uint8Array;
}

declare interface CompactMultiProofInput {
    type: ProofType.compactMulti;
    descriptor: Uint8Array;
}

declare const CompactMultiProofType: ContainerType<{
    leaves: ArrayType<Type<Uint8Array<ArrayBufferLike>>, unknown, unknown>;
    descriptor: ByteListType;
}>;

/**
 * Input element type accepted by the outer composite.
 * When the element is a basic vector/list, allow any `ArrayLike` of the basic value
 * (e.g. `Uint32Array` for a `VectorBasicType<UintNumberType>`), not only plain `number[]`.
 */
declare type CompositeElementInput<ElementType extends Type<unknown>> = ElementType extends VectorBasicType<infer B> ? ArrayLike_2<ValueOf<B>> : ElementType extends ListBasicType<infer B> ? ArrayLike_2<ValueOf<B>> : ValueOf<ElementType>;

/**
 * Represents a composite type as defined in the spec:
 * https://github.com/ethereum/consensus-specs/blob/v1.6.1/ssz/simple-serialize.md#composite-types
 */
declare abstract class CompositeType<V, TV, TVDU> extends Type<V> {
    /**
     * Caches `hashTreeRoot()` result for struct values.
     *
     * WARNING: Must only be used for immutable values. The cached root is never discarded
     */
    protected readonly cachePermanentRootStruct?: boolean | undefined;
    readonly isBasic = false;
    /**
     * True if the merkleization of this type has a right node with metadata.
     * i.e. ListBasic, ListComposite, BitList, ByteList.
     */
    abstract readonly isList: boolean;
    /**
     * False if the TreeView of this type is immutable. Example:
     * - Any BasicType
     * - ByteVector, ByteList
     *
     * Required for ContainerNodeStruct to ensure no dangerous types are constructed.
     */
    abstract readonly isViewMutable: boolean;
    protected blocksBuffer: Uint8Array<ArrayBuffer>;
    constructor(
    /**
     * Caches `hashTreeRoot()` result for struct values.
     *
     * WARNING: Must only be used for immutable values. The cached root is never discarded
     */
    cachePermanentRootStruct?: boolean | undefined);
    /** New instance of a recursive zero'ed value converted to Tree View */
    defaultView(): TV;
    /** New instance of a recursive zero'ed value converted to Deferred Update Tree View */
    defaultViewDU(): TVDU;
    /**
     * Returns a {@link TreeView}.
     *
     * A Tree View is a wrapper around a type and an SSZ Tree that contains:
     * - data merkleized
     * - a hook to its parent Tree to propagate changes upwards
     *
     * **View**
     * - Best for simple usage where performance is NOT important
     * - Applies changes immediately
     * - Has reference to parent tree
     * - Does NOT have caches for fast get / set ops
     *
     * **ViewDU**
     * - Best for complex usage where performance is important
     * - Defers changes to when commit is called
     * - Does NOT have a reference to the parent ViewDU
     * - Has caches for fast get / set ops
     */
    abstract getView(tree: Tree): TV;
    /**
     * Returns a {@link TreeViewDU} - Deferred Update Tree View.
     *
     * A Deferred Update Tree View is a wrapper around a type and
     * a SSZ Node that contains:
     * - data merkleized
     * - some arbitrary caches to speed up data manipulation required by the type
     *
     * **View**
     * - Best for simple usage where performance is NOT important
     * - Applies changes immediately
     * - Has reference to parent tree
     * - Does NOT have caches for fast get / set ops
     *
     * **ViewDU**
     * - Best for complex usage where performance is important
     * - Defers changes to when commit is called
     * - Does NOT have a reference to the parent ViewDU
     * - Has caches for fast get / set ops
     */
    abstract getViewDU(node: Node_2, cache?: unknown): TVDU;
    /** INTERNAL METHOD: Given a Tree View, returns a `Node` with all its updated data */
    abstract commitView(view: TV): Node_2;
    /** INTERNAL METHOD: Given a Deferred Update Tree View returns a `Node` with all its updated data */
    abstract commitViewDU(view: TVDU, hcOffset?: number, hcByLevel?: HashComputationLevel[] | null): Node_2;
    /** INTERNAL METHOD: Return the cache of a Deferred Update Tree View. May return `undefined` if this ViewDU has no cache */
    abstract cacheOfViewDU(view: TVDU): unknown;
    /**
     * Deserialize binary data to a Tree View.
     * @see {@link CompositeType.getView}
     */
    deserializeToView(data: Uint8Array): TV;
    /**
     * Deserialize binary data to a Deferred Update Tree View.
     * @see {@link CompositeType.getViewDU}
     */
    deserializeToViewDU(data: Uint8Array): TVDU;
    /**
     * Transform value to a View.
     * @see {@link CompositeType.getView}
     */
    toView(value: V): TV;
    /**
     * Transform value to a ViewDU.
     * @see {@link CompositeType.getViewDU}
     */
    toViewDU(value: V): TVDU;
    /**
     * Transform value to a View.
     * @see {@link CompositeType.getView}
     */
    toValueFromView(view: TV): V;
    /**
     * Transform value to a ViewDU.
     * @see {@link CompositeType.getViewDU}
     */
    toValueFromViewDU(view: TVDU): V;
    /**
     * Transform a ViewDU to a View.
     * @see {@link CompositeType.getView} and {@link CompositeType.getViewDU}
     */
    toViewFromViewDU(view: TVDU): TV;
    /**
     * Transform a View to a ViewDU.
     * @see {@link CompositeType.getView} and {@link CompositeType.getViewDU}
     */
    toViewDUFromView(view: TV): TVDU;
    hashTreeRoot(value: V): Uint8Array;
    hashTreeRootInto(value: V, output: Uint8Array, offset: number, safeCache?: boolean): void;
    protected getCachedPermanentRoot(value: V): Uint8Array | undefined;
    abstract readonly maxChunkCount: number;
    /**
     * Get multiple SHA256 blocks, each is 64 bytes long.
     * If chunk count is not even, need to append zeroHash(0)
     */
    protected abstract getBlocksBytes(value: V): Uint8Array;
    /**
     * Create a Tree View from a Proof. Verifies that the Proof is correct against `root`.
     * @see {@link CompositeType.getView}
     */
    createFromProof(proof: Proof, root?: Uint8Array): TV;
    /** INTERNAL METHOD: For view's API, create proof from a tree */
    tree_createProof(node: Node_2, jsonPaths: JsonPath[]): Proof;
    /** INTERNAL METHOD: For view's API, create proof from a tree */
    tree_createProofGindexes(node: Node_2, jsonPaths: JsonPath[]): Gindex[];
    /**
     * Navigate to a subtype & gindex using a path
     */
    getPathInfo(path: JsonPath): {
        gindex: Gindex;
        type: Type<unknown>;
    };
    /**
     * INTERNAL METHOD: post process `Ǹode` instance created from a proof and return either the same node,
     * and a new node representing the same data is a different `Node` instance. Currently used exclusively
     * by ContainerNodeStruct to convert `BranchNode` into `BranchNodeStruct`.
     */
    tree_fromProofNode(node: Node_2): {
        node: Node_2;
        done: boolean;
    };
    /**
     * Get leaf gindices
     *
     * Note: This is a recursively called method.
     * Subtypes recursively call this method until basic types / leaf data is hit.
     *
     * @param node Used for variable-length types.
     * @param root Used to anchor the returned gindices to a non-root gindex.
     * This is used to augment leaf gindices in recursively-called subtypes relative to the type.
     * @returns The gindices corresponding to leaf data.
     */
    abstract tree_getLeafGindices(rootGindex: Gindex, rootNode?: Node_2): Gindex[];
    /** Return the generalized index for the subtree. May return null if must not navigate below this type */
    abstract getPropertyGindex(property: JsonPathProp): Gindex | null;
    /** Return the property's subtype if the property exists */
    abstract getPropertyType(property: JsonPathProp): Type<unknown>;
    /** Return a leaf node index's property if the index is within bounds */
    abstract getIndexProperty(index: number): JsonPathProp | null;
}

/** View type of a CompositeType */
declare type CompositeView<T extends CompositeType<unknown, unknown, unknown>> = T extends CompositeType<unknown, infer TV, unknown> ? TV : never;

/** ViewDU type of a CompositeType */
declare type CompositeViewDU<T extends CompositeType<unknown, unknown, unknown>> = T extends CompositeType<unknown, unknown, infer TVDU> ? TVDU : never;

/**
 * Return the domain for the [[domainType]] and [[forkVersion]].
 */
declare function computeDomain(domainType: DomainType_2, forkVersion: Version_2, genesisValidatorRoot: Root_2): Uint8Array;

/**
 * Return the epoch number at the given slot.
 */
declare function computeEpochAtSlot(slot: Slot_2): Epoch;

/**
 * Used primarily in signature domains to avoid collisions across forks/chains.
 */
declare function computeForkDataRoot(currentVersion: Version_2, genesisValidatorsRoot: Root_2): Uint8Array;

/**
 * Return the signing root of an object by calculating the root of the object-domain tree.
 */
declare function computeSigningRoot<T>(type: Type<T>, sszObject: T, domain: Domain_2): Uint8Array;

/**
 * Return the sync committee period at epoch
 */
declare function computeSyncPeriodAtEpoch(epoch: Epoch): SyncPeriod_2;

/**
 * Return the sync committee period at slot
 */
declare function computeSyncPeriodAtSlot(slot: Slot_2): SyncPeriod_2;

declare namespace config {
    export {
        getDefinitions_6 as getDefinitions,
        DepositContractType,
        ForkListType,
        DepositContract,
        ForkList,
        Spec,
        Endpoints_7 as Endpoints
    }
}

declare const ConsolidationRequest: ContainerType<{
    sourceAddress: ExecutionAddressType;
    sourcePubkey: ByteVectorType;
    targetPubkey: ByteVectorType;
}>;

declare type ConsolidationRequest_2 = ValueOf<typeof ssz_7.ConsolidationRequest>;

declare const ConsolidationRequests: ListCompositeType<ContainerType<{
    sourceAddress: ExecutionAddressType;
    sourcePubkey: ByteVectorType;
    targetPubkey: ByteVectorType;
}>>;

declare type ConsolidationRequests_2 = ValueOf<typeof ssz_7.ConsolidationRequests>;

/**
 * ContainerNodeStruct: ordered heterogeneous collection of values.
 * - Notation: Custom name per instance
 *
 * A ContainerNodeStruct is identical to a Container type except that it represents tree data with a custom
 * BranchNodeStruct node. This special branch node represents the data of its entire sub tree as a value, instead
 * of a tree of nodes. This approach is a tradeoff:
 *
 * - More memory efficient
 * - Faster reads, since it doesn't require parsing merkleized data
 * - Slower hashing, since it has to merkleize the entire value everytime and has not intermediary hashing cache
 *
 * This tradeoff is good for data that is read often, written rarely, and consumes a lot of memory (i.e. Validator)
 */
declare class ContainerNodeStructType<Fields extends Record<string, Type<unknown>>> extends ContainerType<Fields> {
    readonly fields: Fields;
    constructor(fields: Fields, opts?: ContainerOptions<Fields>);
    static named<Fields extends Record<string, Type<unknown>>>(fields: Fields, opts: Require<ContainerOptions<Fields>, "typeName">): ContainerType<Fields>;
    tree_serializedSize(node: Node_2): number;
    tree_serializeToBytes(output: ByteViews, offset: number, node: Node_2): number;
    tree_deserializeFromBytes(data: ByteViews, start: number, end: number): Node_2;
    getPropertyGindex(): null;
    tree_fromProofNode(node: Node_2): {
        node: Node_2;
        done: boolean;
    };
    tree_toValue(node: Node_2): ValueOfFields<Fields>;
    value_toTree(value: ValueOfFields<Fields>): Node_2;
    private valueToTree;
}

declare type ContainerOptions<Fields extends Record<string, unknown>> = {
    typeName?: string;
    jsonCase?: KeyCase;
    casingMap?: CasingMap<Fields>;
    cachePermanentRootStruct?: boolean;
    getContainerTreeViewClass?: typeof getContainerTreeViewClass;
    getContainerTreeViewDUClass?: typeof getContainerTreeViewDUClass;
};

declare type ContainerTreeViewDUType<Fields extends Record<string, Type<unknown>>> = FieldsViewDU<Fields> & TreeViewDU<ContainerTypeGeneric<Fields>>;

declare type ContainerTreeViewDUTypeConstructor<Fields extends Record<string, Type<unknown>>> = {
    new (type: ContainerTypeGeneric<Fields>, node: Node_2, cache?: unknown): ContainerTreeViewDUType<Fields>;
};

declare type ContainerTreeViewType<Fields extends Record<string, Type<unknown>>> = FieldsView<Fields> & TreeView<BasicContainerTypeGeneric<Fields>>;

declare type ContainerTreeViewTypeConstructor<Fields extends Record<string, Type<unknown>>> = {
    new (type: ContainerTypeGeneric<Fields>, tree: Tree): ContainerTreeViewType<Fields>;
};

/**
 * Container: ordered heterogeneous collection of values
 * - Notation: Custom name per instance
 */
declare class ContainerType<Fields extends Record<string, Type<unknown>>> extends CompositeType<ValueOfFields<Fields>, ContainerTreeViewType<Fields>, ContainerTreeViewDUType<Fields>> {
    readonly fields: Fields;
    readonly opts?: ContainerOptions<Fields> | undefined;
    readonly typeName: string;
    readonly depth: number;
    readonly maxChunkCount: number;
    readonly fixedSize: number | null;
    readonly minSize: number;
    readonly maxSize: number;
    readonly isList = false;
    readonly isViewMutable = true;
    readonly fieldsEntries: FieldEntry<Fields>[];
    /** End of fixed section of serialized Container */
    readonly fixedEnd: number;
    protected readonly fieldsGindex: Record<keyof Fields, Gindex>;
    protected readonly jsonKeyToFieldName: Record<string, keyof Fields>;
    protected readonly isFixedLen: boolean[];
    protected readonly fieldRangesFixedLen: BytesRange[];
    /** Offsets position relative to start of serialized Container. Length may not equal field count. */
    protected readonly variableOffsetsPosition: number[];
    /** Cached TreeView constuctor with custom prototype for this Type's properties */
    protected readonly TreeView: ContainerTreeViewTypeConstructor<Fields>;
    protected readonly TreeViewDU: ContainerTreeViewDUTypeConstructor<Fields>;
    constructor(fields: Fields, opts?: ContainerOptions<Fields> | undefined);
    static named<Fields extends Record<string, Type<unknown>>>(fields: Fields, opts: Require<ContainerOptions<Fields>, "typeName">): ContainerType<Fields>;
    defaultValue(): ValueOfFields<Fields>;
    getView(tree: Tree): ContainerTreeViewType<Fields>;
    getViewDU(node: Node_2, cache?: unknown): ContainerTreeViewDUType<Fields>;
    cacheOfViewDU(view: ContainerTreeViewDUType<Fields>): unknown;
    commitView(view: ContainerTreeViewType<Fields>): Node_2;
    commitViewDU(view: ContainerTreeViewDUType<Fields>, hcOffset?: number, hcByLevel?: HashComputationLevel[] | null): Node_2;
    value_serializedSize(value: ValueOfFields<Fields>): number;
    value_serializeToBytes(output: ByteViews, offset: number, value: ValueOfFields<Fields>): number;
    value_deserializeFromBytes(data: ByteViews, start: number, end: number, reuseBytes?: boolean): ValueOfFields<Fields>;
    tree_serializedSize(node: Node_2): number;
    tree_serializeToBytes(output: ByteViews, offset: number, node: Node_2): number;
    tree_deserializeFromBytes(data: ByteViews, start: number, end: number): Node_2;
    protected getBlocksBytes(struct: ValueOfFields<Fields>): Uint8Array;
    getPropertyGindex(prop: string): Gindex | null;
    getPropertyType(prop: string): Type<unknown>;
    getIndexProperty(index: number): string | null;
    tree_getLeafGindices(rootGindex: Gindex, rootNode?: Node_2): Gindex[];
    fromJson(json: unknown): ValueOfFields<Fields>;
    toJson(value: ValueOfFields<Fields>): Record<string, unknown>;
    clone(value: ValueOfFields<Fields>): ValueOfFields<Fields>;
    equals(a: ValueOfFields<Fields>, b: ValueOfFields<Fields>): boolean;
    /**
     * Deserializer helper: Returns the bytes ranges of all fields, both variable and fixed size.
     * Fields may not be contiguous in the serialized bytes, so the returned ranges are [start, end].
     * - For fixed size fields re-uses the pre-computed values this.fieldRangesFixedLen
     * - For variable size fields does a first pass over the fixed section to read offsets
     */
    getFieldRanges(data: DataView, start: number, end: number): BytesRange[];
}

declare type ContainerTypeGeneric<Fields extends Record<string, Type<unknown>>> = BasicContainerTypeGeneric<Fields> & {
    readonly fixedEnd: number;
};

declare const ContributionAndProof: ContainerType<{
    aggregatorIndex: UintNumberType;
    contribution: ContainerType<{
        slot: UintNumberType;
        beaconBlockRoot: ByteVectorType;
        subcommitteeIndex: UintNumberType;
        aggregationBits: BitVectorType;
        signature: ByteVectorType;
    }>;
    selectionProof: ByteVectorType;
}>;

declare type ContributionAndProof_2 = ValueOf<typeof ssz_3.ContributionAndProof>;

/**
 * NOTE: This MUST match the type used in @chainsafe/blst.  Do not use the one
 * exported by that library though or it will mess up tree shaking.  Use the one
 * below instead by MAKE SURE if you change this that it matches the enum values
 * used by the native bindings in the base library!!!!  Better yet do not modify
 * this unless you are ABSOLUTELY SURE you know what you are doing...
 */
/**
 * CoordType allows switching between affine and jacobian version of underlying
 * bls points.
 */
declare enum CoordType {
    affine = 0,
    jacobian = 1
}

declare const CurrentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;

declare const CurrentSyncCommitteeBranch_2: VectorCompositeType<ByteVectorType>;

declare const CustodyIndex: UintNumberType;

declare type CustodyInfo = {
    /** Earliest slot for which the node has custodied data columns */
    earliestCustodiedSlot: Slot_2;
    /** Number of custody groups the node is responsible for */
    custodyGroupCount: number;
    /** List of column indices the node is custodying */
    custodyColumns: number[];
};

declare const DataColumn: ListCompositeType<ByteVectorType>;

declare type DataColumn_2 = ValueOf<typeof ssz_8.DataColumn>;

declare const DataColumns: ListCompositeType<ListCompositeType<ByteVectorType>>;

declare const DataColumnsByRootIdentifier: ContainerType<{
    blockRoot: ByteVectorType;
    columns: ListBasicType<UintNumberType>;
}>;

declare type DataColumnsByRootIdentifier_2 = ValueOf<typeof ssz_8.DataColumnsByRootIdentifier>;

declare const DataColumnSidecar: ContainerType<{
    index: UintNumberType;
    column: ListCompositeType<ByteVectorType>;
    kzgCommitments: ListCompositeType<ByteVectorType>;
    kzgProofs: ListCompositeType<ByteVectorType>;
    signedBlockHeader: ContainerType<{
        message: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        signature: ByteVectorType;
    }>;
    kzgCommitmentsInclusionProof: VectorCompositeType<ByteVectorType>;
}>;

declare type DataColumnSidecar_2 = ValueOf<typeof ssz_8.DataColumnSidecar>;

declare const DataColumnSidecar_3: ContainerType<{
    index: UintNumberType;
    column: ListCompositeType<ByteVectorType>;
    kzgProofs: ListCompositeType<ByteVectorType>;
    slot: UintNumberType;
    beaconBlockRoot: ByteVectorType;
}>;

declare type DataColumnSidecar_4 = ValueOf<typeof ssz_9.DataColumnSidecar>;

declare const DataColumnSidecars: ListCompositeType<ContainerType<{
    index: UintNumberType;
    column: ListCompositeType<ByteVectorType>;
    kzgCommitments: ListCompositeType<ByteVectorType>;
    kzgProofs: ListCompositeType<ByteVectorType>;
    signedBlockHeader: ContainerType<{
        message: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        signature: ByteVectorType;
    }>;
    kzgCommitmentsInclusionProof: VectorCompositeType<ByteVectorType>;
}>>;

declare type DataColumnSidecars_2 = ValueOf<typeof ssz_8.DataColumnSidecars>;

declare const DataColumnSidecars_3: ListCompositeType<ContainerType<{
    index: UintNumberType;
    column: ListCompositeType<ByteVectorType>;
    kzgProofs: ListCompositeType<ByteVectorType>;
    slot: UintNumberType;
    beaconBlockRoot: ByteVectorType;
}>>;

declare type DataColumnSidecars_4 = ValueOf<typeof ssz_9.DataColumnSidecars>;

declare type DataColumnSidecars_5<F extends ForkPostFulu = ForkPostFulu> = TypesByFork[F]["DataColumnSidecars"];

declare const DataColumnSidecarsByRangeRequest: ContainerType<{
    startSlot: UintNumberType;
    count: UintNumberType;
    columns: ListBasicType<UintNumberType>;
}>;

declare type DataColumnSidecarsByRangeRequest_2 = ValueOf<typeof ssz_8.DataColumnSidecarsByRangeRequest>;

declare type DataColumnSidecarSSE = FuluDataColumnSidecarSSE | GloasDataColumnSidecarSSE;

declare namespace debug {
    export {
        getDefinitions_7 as getDefinitions,
        Endpoints_8 as Endpoints
    }
}

declare type DebugChainHeadList = ValueOf<typeof DebugChainHeadListType>;

declare const DebugChainHeadListType: ArrayType<Type<ValueOfFields<    {
slot: UintNumberType;
root: StringType<string>;
executionOptimistic: BooleanType;
}>>, unknown, unknown>;

declare const Deposit: ContainerType<{
    proof: VectorCompositeType<ByteVectorType>;
    data: ContainerType<{
        pubkey: ByteVectorType;
        withdrawalCredentials: ByteVectorType;
        amount: UintNumberType;
        signature: ByteVectorType;
    }>;
}>;

declare type Deposit_2 = ValueOf<typeof ssz_2.Deposit>;

declare type DepositContract = ValueOf<typeof DepositContractType>;

declare const DepositContractType: ContainerType<{
    chainId: UintNumberType;
    address: ExecutionAddressType;
}>;

declare const DepositData: ContainerType<{
    pubkey: ByteVectorType;
    withdrawalCredentials: ByteVectorType;
    amount: UintNumberType;
    signature: ByteVectorType;
}>;

declare type DepositData_2 = ValueOf<typeof ssz_2.DepositData>;

declare const DepositDataRootList: ListCompositeType<ByteVectorType>;

declare const DepositEvent: ContainerType<{
    depositData: ContainerType<{
        pubkey: ByteVectorType;
        withdrawalCredentials: ByteVectorType;
        amount: UintNumberType;
        signature: ByteVectorType;
    }>;
    blockNumber: UintNumberType;
    index: UintNumberType;
}>;

declare type DepositEvent_2 = ValueOf<typeof ssz_2.DepositEvent>;

declare const DepositIndex: UintBigintType;

declare const DepositMessage: ContainerType<{
    pubkey: ByteVectorType;
    withdrawalCredentials: ByteVectorType;
    amount: UintNumberType;
}>;

declare type DepositMessage_2 = ValueOf<typeof ssz_2.DepositMessage>;

declare const DepositRequest: ContainerType<{
    pubkey: ByteVectorType;
    withdrawalCredentials: ByteVectorType;
    amount: UintNumberType;
    signature: ByteVectorType;
    index: UintBigintType;
}>;

declare type DepositRequest_2 = ValueOf<typeof ssz_7.DepositRequest>;

declare const DepositRequests: ListCompositeType<ContainerType<{
    pubkey: ByteVectorType;
    withdrawalCredentials: ByteVectorType;
    amount: UintNumberType;
    signature: ByteVectorType;
    index: UintBigintType;
}>>;

declare type DepositRequests_2 = ValueOf<typeof ssz_7.DepositRequests>;

declare function deserializeSyncCommittee(syncCommittee: ts_2.SyncCommittee): SyncCommitteeFast;

/**
 * A multiaddr with peer ID or ENR string.
 *
 * Supported formats:
 * - Multiaddr with peer ID: `/ip4/192.168.1.1/tcp/9000/p2p/16Uiu2HAmKLhW7...`
 * - ENR: `enr:-IS4QHCYrYZbAKWCBRlAy5zzaDZXJBGkcnh4MHcBFZntXNFrdvJjX04jRzjzCBOo...`
 *
 * For multiaddrs, the string must contain a /p2p/ component with the peer ID.
 * For ENRs, the TCP multiaddr and peer ID are extracted from the encoded record.
 */
declare type DirectPeer = string;

declare const Domain: ByteVectorType;

declare type Domain_2 = Bytes32_2;

declare const DomainType: ByteVectorType;

declare type DomainType_2 = Bytes4_2;

declare type EmptyArgs = void;

declare type EmptyMeta = void;

declare type EmptyRequest = Record<never, never>;

declare type EmptyResponseData = void;

/**
 * This type describes the general shape of a route
 *
 * This includes both http and application-level shape
 * - The http method
 *   - Used to more strictly enforce the shape of the request
 * - The application-level parameters
 *   - this enforces the shape of the input data passed by the client and to the route handler
 * - The http request
 *   - this enforces the shape of the querystring, url params, request body
 * - The application-level return data
 *   - this enforces the shape of the output data passed back to the client and returned by the route handler
 * - The application-level return metadata
 *   - this enforces the shape of the returned metadata, used informationally and to help decode the return data
 */
declare type Endpoint<Method extends HttpMethod = HttpMethod, ArgsType = unknown, RequestType extends Method extends "GET" ? RequestData : JsonRequestData = JsonRequestData, ReturnType = unknown, Meta = unknown> = {
    method: Method;
    /** The parameters the client passes / server app code ingests */
    args: ArgsType;
    /** The parameters in the http request */
    request: RequestType;
    /** The return data */
    return: ReturnType;
    /** The return metadata */
    meta: Meta;
};

declare type Endpoints = {
    beacon: Endpoints_2;
    config: Endpoints_7;
    debug: Endpoints_8;
    events: Endpoints_9;
    lightclient: Endpoints_10;
    lodestar: Endpoints_11;
    node: Endpoints_12;
    proof: Endpoints_13;
    validator: Endpoints_14;
};

declare type Endpoints_10 = {
    /**
     * Returns an array of best updates given a `startPeriod` and `count` number of sync committee period to return.
     * Best is defined by (in order of priority):
     * - Is finalized update
     * - Has most bits
     * - Oldest update
     */
    getLightClientUpdatesByRange: Endpoint<"GET", {
        startPeriod: SyncPeriod_2;
        count: number;
    }, {
        query: {
            start_period: number;
            count: number;
        };
    }, LightClientUpdate_9[], {
        versions: ForkName[];
    }>;
    /**
     * Returns the latest optimistic head update available. Clients should use the SSE type `light_client_optimistic_update`
     * unless to get the very first head update after syncing, or if SSE are not supported by the server.
     */
    getLightClientOptimisticUpdate: Endpoint<"GET", EmptyArgs, EmptyRequest, LightClientOptimisticUpdate_9, VersionMeta>;
    getLightClientFinalityUpdate: Endpoint<"GET", EmptyArgs, EmptyRequest, LightClientFinalityUpdate, VersionMeta>;
    /**
     * Fetch a bootstrapping state with a proof to a trusted block root.
     * The trusted block root should be fetched with similar means to a weak subjectivity checkpoint.
     * Only block roots for checkpoints are guaranteed to be available.
     */
    getLightClientBootstrap: Endpoint<"GET", {
        blockRoot: string;
    }, {
        params: {
            block_root: string;
        };
    }, LightClientBootstrap_9, VersionMeta>;
    /**
     * Returns an array of sync committee hashes based on the provided period and count
     */
    getLightClientCommitteeRoot: Endpoint<"GET", {
        startPeriod: SyncPeriod_2;
        count: number;
    }, {
        query: {
            start_period: number;
            count: number;
        };
    }, HashList, EmptyMeta>;
};

declare type Endpoints_11 = {
    /** Trigger to write a heapdump to disk at `dirpath`. May take > 1min */
    writeHeapdump: Endpoint<"POST", {
        thread?: LodestarThreadType;
        dirpath?: string;
    }, {
        query: {
            thread?: LodestarThreadType;
            dirpath?: string;
        };
    }, {
        filepath: string;
    }, EmptyMeta>;
    /** Trigger to write 10m network thread profile to disk */
    writeProfile: Endpoint<"POST", {
        thread?: LodestarThreadType;
        duration?: number;
        dirpath?: string;
    }, {
        query: {
            thread?: LodestarThreadType;
            duration?: number;
            dirpath?: string;
        };
    }, {
        result: string;
    }, EmptyMeta>;
    /** TODO: description */
    getLatestWeakSubjectivityCheckpointEpoch: Endpoint<"GET", EmptyArgs, EmptyRequest, Epoch, EmptyMeta>;
    /** TODO: description */
    getSyncChainsDebugState: Endpoint<"GET", EmptyArgs, EmptyRequest, SyncChainDebugState[], EmptyMeta>;
    /** Dump all items in a gossip queue, by gossipType */
    getGossipQueueItems: Endpoint<"GET", {
        gossipType: string;
    }, {
        params: {
            gossipType: string;
        };
    }, unknown[], EmptyMeta>;
    /** Dump all items in the regen queue */
    getRegenQueueItems: Endpoint<"GET", EmptyArgs, EmptyRequest, RegenQueueItem[], EmptyMeta>;
    /** Dump all items in the block processor queue */
    getBlockProcessorQueueItems: Endpoint<"GET", EmptyArgs, EmptyRequest, BlockProcessorQueueItem[], EmptyMeta>;
    /** Dump a summary of the states in the block state cache and checkpoint state cache */
    getStateCacheItems: Endpoint<"GET", EmptyArgs, EmptyRequest, StateCacheItem[], EmptyMeta>;
    /** Dump peer gossip stats by peer */
    getGossipPeerScoreStats: Endpoint<"GET", EmptyArgs, EmptyRequest, GossipPeerScoreStat[], EmptyMeta>;
    /** Dump lodestar score stats by peer */
    getLodestarPeerScoreStats: Endpoint<"GET", EmptyArgs, EmptyRequest, PeerScoreStat[], EmptyMeta>;
    /** Run GC with `global.gc()` */
    runGC: Endpoint<"POST", EmptyArgs, EmptyRequest, EmptyResponseData, EmptyMeta>;
    /** Drop all states in the state cache */
    dropStateCache: Endpoint<"POST", EmptyArgs, EmptyRequest, EmptyResponseData, EmptyMeta>;
    /** Connect to peer at this multiaddress */
    connectPeer: Endpoint<"POST", {
        peerId: string;
        multiaddrs: string[];
    }, {
        query: {
            peerId: string;
            multiaddr: string[];
        };
    }, EmptyResponseData, EmptyMeta>;
    /** Disconnect peer */
    disconnectPeer: Endpoint<"POST", {
        peerId: string;
    }, {
        query: {
            peerId: string;
        };
    }, EmptyResponseData, EmptyMeta>;
    /**
     * Add a direct peer at runtime.
     * Direct peers maintain permanent mesh connections without GRAFT/PRUNE negotiation.
     * Accepts either a multiaddr with peer ID or an ENR string.
     */
    addDirectPeer: Endpoint<"POST", {
        peer: DirectPeer;
    }, {
        query: {
            peer: string;
        };
    }, {
        peerId: string;
    }, EmptyMeta>;
    /** Remove a peer from direct peers */
    removeDirectPeer: Endpoint<"DELETE", {
        peerId: string;
    }, {
        query: {
            peerId: string;
        };
    }, {
        removed: boolean;
    }, EmptyMeta>;
    /** Get list of direct peer IDs */
    getDirectPeers: Endpoint<"GET", EmptyArgs, EmptyRequest, string[], EmptyMeta>;
    /** Same to node api with new fields */
    getPeers: Endpoint<"GET", FilterGetPeers, {
        query: {
            state?: PeerState[];
            direction?: PeerDirection[];
        };
    }, LodestarNodePeer[], {
        count: number;
    }>;
    /** Returns root/slot of blacklisted blocks */
    getBlacklistedBlocks: Endpoint<"GET", EmptyArgs, EmptyRequest, BlacklistedBlock[], EmptyMeta>;
    /** Returns historical summaries and proof for a given state ID */
    getHistoricalSummaries: Endpoint<"GET", StateArgs, {
        params: {
            state_id: string;
        };
    }, HistoricalSummariesResponse, ExecutionOptimisticFinalizedAndVersionMeta>;
    getPersistedCheckpointState: Endpoint<"GET", {
        /** The checkpoint in `<root>:<epoch>` format to be returned instead of the latest safe checkpoint state */
        checkpointId?: string;
    }, {
        query: {
            checkpoint_id?: string;
        };
    }, BeaconState_17, VersionMeta>;
    /**
     * Returns the validator indices that are currently being monitored by the validator monitor.
     */
    getMonitoredValidatorIndices: Endpoint<"GET", EmptyArgs, EmptyRequest, ValidatorIndex_2[], EmptyMeta>;
    /** Dump Discv5 Kad values */
    discv5GetKadValues: Endpoint<"GET", EmptyArgs, EmptyRequest, string[], EmptyMeta>;
    /**
     * Dump level-db entry keys for a given Bucket declared in code, or for all buckets.
     */
    dumpDbBucketKeys: Endpoint<"GET", {
        /** Must be the string name of a bucket entry: `allForks_blockArchive` */
        bucket: string;
    }, {
        params: {
            bucket: string;
        };
    }, string[], EmptyMeta>;
    /** Return all entries in the StateArchive index with bucket index_stateArchiveRootIndex */
    dumpDbStateIndex: Endpoint<"GET", EmptyArgs, EmptyRequest, {
        root: RootHex;
        slot: Slot_2;
    }[], EmptyMeta>;
    /** Get custody information for data columns */
    getCustodyInfo: Endpoint<"GET", EmptyArgs, EmptyRequest, CustodyInfo, EmptyMeta>;
    /** Craft attester slashings from the attestations in the provided blocks */
    getAttesterSlashingsFromBlocks: Endpoint<"POST", {
        signedBlocks: SignedBeaconBlock_17[];
    }, {
        body: unknown;
        headers: {
            [MetaHeader.Version]: string;
        };
    }, AttesterSlashing_5[], VersionMeta>;
};

/**
 * Read information about the beacon node.
 */
declare type Endpoints_12 = {
    /**
     * Get node network identity
     * Retrieves data about the node's network presence
     */
    getNetworkIdentity: Endpoint<"GET", EmptyArgs, EmptyRequest, NetworkIdentity, EmptyMeta>;
    /**
     * Get node network peers
     * Retrieves data about the node's network peers. By default this returns all peers. Multiple query params are combined using AND conditions
     */
    getPeers: Endpoint<"GET", FilterGetPeers, {
        query: {
            state?: PeerState[];
            direction?: PeerDirection[];
        };
    }, NodePeers, PeersMeta>;
    /**
     * Get peer
     * Retrieves data about the given peer
     */
    getPeer: Endpoint<"GET", {
        peerId: string;
    }, {
        params: {
            peer_id: string;
        };
    }, NodePeer, EmptyMeta>;
    /**
     * Get peer count
     * Retrieves number of known peers.
     */
    getPeerCount: Endpoint<"GET", EmptyArgs, EmptyRequest, PeerCount, EmptyMeta>;
    /**
     * Get version string of the running beacon node.
     * Requests that the beacon node identify information about its implementation in a format similar to a [HTTP User-Agent](https://tools.ietf.org/html/rfc7231#section-5.5.3) field.
     */
    getNodeVersion: Endpoint<"GET", EmptyArgs, EmptyRequest, {
        version: string;
    }, EmptyMeta>;
    /**
     * Get version information for the beacon node and execution client.
     * Retrieves structured information about the version of the beacon node and its attached execution client
     * in the same format as used on the
     * [Engine API](https://github.com/ethereum/execution-apis/blob/dc4dbca37ef8697d782f431af19120beaf5517f5/src/engine/identification.md).
     *
     * Version information about the execution client may not be available at all times and is therefore optional.
     *
     * If the beacon node receives multiple values from `engine_getClientVersionV1`,
     * the first value should be returned on this endpoint.
     */
    getNodeVersionV2: Endpoint<"GET", EmptyArgs, EmptyRequest, NodeVersionV2, EmptyMeta>;
    /**
     * Get node syncing status
     * Requests the beacon node to describe if it's currently syncing or not, and if it is, what block it is up to.
     */
    getSyncingStatus: Endpoint<"GET", EmptyArgs, EmptyRequest, SyncingStatus, EmptyMeta>;
    /**
     * Get health check
     * Returns node health status in http status codes. Useful for load balancers.
     */
    getHealth: Endpoint<"GET", {
        syncingStatus?: number;
    }, {
        query: {
            syncing_status?: number;
        };
    }, EmptyResponseData, EmptyMeta>;
};

declare type Endpoints_13 = {
    /**
     * Returns a multiproof of `descriptor` at the requested `stateId`.
     * The requested `stateId` may not be available. Regular nodes only keep recent states in memory.
     */
    getStateProof: Endpoint<"GET", {
        stateId: string;
        descriptor: Uint8Array;
    }, {
        params: {
            state_id: string;
        };
        query: {
            format: string;
        };
    }, CompactMultiProof, VersionMeta>;
    /**
     * Returns a multiproof of `descriptor` at the requested `blockId`.
     * The requested `blockId` may not be available. Regular nodes only keep recent states in memory.
     */
    getBlockProof: Endpoint<"GET", {
        blockId: string;
        descriptor: Uint8Array;
    }, {
        params: {
            block_id: string;
        };
        query: {
            format: string;
        };
    }, CompactMultiProof, VersionMeta>;
};

declare type Endpoints_14 = {
    /**
     * Get attester duties
     * Requests the beacon node to provide a set of attestation duties, which should be performed by validators, for a particular epoch.
     * Duties should only need to be checked once per epoch, however a chain reorganization (of > MIN_SEED_LOOKAHEAD epochs) could occur, resulting in a change of duties. For full safety, you should monitor head events and confirm the dependent root in this response matches:
     * - event.previous_duty_dependent_root when `compute_epoch_at_slot(event.slot) == epoch`
     * - event.current_duty_dependent_root when `compute_epoch_at_slot(event.slot) + 1 == epoch`
     * - event.block otherwise
     * The dependent_root value is `get_block_root_at_slot(state, compute_start_slot_at_epoch(epoch - 1) - 1)` or the genesis block root in the case of underflow.
     */
    getAttesterDuties: Endpoint<"POST", {
        /** Should only be allowed 1 epoch ahead */
        epoch: Epoch;
        /** An array of the validator indices for which to obtain the duties */
        indices: ValidatorIndices;
    }, {
        params: {
            epoch: Epoch;
        };
        body: unknown;
    }, AttesterDutyList, ExecutionOptimisticAndDependentRootMeta>;
    /**
     * Get block proposers duties
     * Request beacon node to provide all validators that are scheduled to propose a block in the given epoch.
     * Duties should only need to be checked once per epoch, however a chain reorganization could occur that results in a change of duties. For full safety, you should monitor head events and confirm the dependent root in this response matches:
     * - event.current_duty_dependent_root when `compute_epoch_at_slot(event.slot) == epoch`
     * - event.block otherwise
     * The dependent_root value is `get_block_root_at_slot(state, compute_start_slot_at_epoch(epoch) - 1)` or the genesis block root in the case of underflow.
     */
    getProposerDuties: Endpoint<"GET", {
        epoch: Epoch;
    }, {
        params: {
            epoch: Epoch;
        };
    }, ProposerDutyList, ExecutionOptimisticAndDependentRootMeta>;
    /**
     * Get block proposers duties
     * Request beacon node to provide all validators that are scheduled to propose a block in the given epoch.
     * Duties should only need to be checked once per epoch, however a chain reorganization could occur that results in a change of duties.
     * For full safety, you should monitor head events and confirm the dependent root in this response matches. After Fulu, different checks
     * need to be performed as the dependent root changes due to deterministic proposer lookahead.
     *
     * Before Fulu:
     *  - event.current_duty_dependent_root when `compute_epoch_at_slot(event.slot) == epoch`
     *  - event.block otherwise
     *  - dependent_root value is `get_block_root_at_slot(state, compute_start_slot_at_epoch(epoch) - 1)`
     *
     * After Fulu:
     * - event.previous_duty_dependent_root when `compute_epoch_at_slot(event.slot) == epoch`
     * - event.block otherwise
     * - dependent_root value is `get_block_root_at_slot(state, compute_start_slot_at_epoch(epoch - 1) - 1)`
     *
     * The dependent_root value is the genesis block root in the case of underflow."
     */
    getProposerDutiesV2: Endpoint<"GET", {
        epoch: Epoch;
    }, {
        params: {
            epoch: Epoch;
        };
    }, ProposerDutyList, ExecutionOptimisticAndDependentRootMeta>;
    getSyncCommitteeDuties: Endpoint<"POST", {
        epoch: number;
        indices: ValidatorIndices;
    }, {
        params: {
            epoch: Epoch;
        };
        body: unknown;
    }, SyncDutyList, ExecutionOptimisticMeta>;
    /**
     * Get PTC duties
     * Requests the beacon node to provide a set of Payload Timeliness Committee duties for a particular epoch.
     */
    getPtcDuties: Endpoint<"POST", {
        /** Must not be greater than the next epoch */
        epoch: Epoch;
        /** An array of the validator indices for which to obtain the duties */
        indices: ValidatorIndices;
    }, {
        params: {
            epoch: Epoch;
        };
        body: unknown;
    }, PtcDutyList, ExecutionOptimisticAndDependentRootMeta>;
    /**
     * Requests a beacon node to produce a valid block, which can then be signed by a validator.
     * Metadata in the response indicates the type of block produced, and the supported types of block
     * will be added to as forks progress.
     */
    produceBlockV3: Endpoint<"GET", {
        /** The slot for which the block should be proposed */
        slot: Slot_2;
        /** The validator's randao reveal value */
        randaoReveal: BLSSignature_2;
        /** Arbitrary data validator wants to include in block */
        graffiti?: string;
        skipRandaoVerification?: boolean;
        builderBoostFactor?: UintBn64_2;
    } & ExtraProduceBlockOpts, {
        params: {
            slot: number;
        };
        query: {
            randao_reveal: string;
            graffiti?: string;
            skip_randao_verification?: string;
            fee_recipient?: string;
            builder_selection?: string;
            builder_boost_factor?: string;
            strict_fee_recipient_check?: boolean;
            blinded_local?: boolean;
        };
    }, BlockContents_7 | BlindedBeaconBlock_9, ProduceBlockV3Meta>;
    /**
     * Requests a beacon node to produce a valid block, which can then be signed by a validator.
     *
     * Post-Gloas, proposers submit execution payload bids rather than full execution payloads,
     * so there is no longer a concept of blinded or unblinded blocks. Builders release the payload later.
     * This endpoint is specific to the post-Gloas forks and is not backwards compatible with previous forks.
     */
    produceBlockV4: Endpoint<"GET", {
        /** The slot for which the block should be proposed */
        slot: Slot_2;
        /** The validator's randao reveal value */
        randaoReveal: BLSSignature_2;
        /** Arbitrary data validator wants to include in block */
        graffiti?: string;
        skipRandaoVerification?: boolean;
        builderBoostFactor?: UintBn64_2;
    } & Omit<ExtraProduceBlockOpts, "blindedLocal">, {
        params: {
            slot: number;
        };
        query: {
            randao_reveal: string;
            graffiti?: string;
            skip_randao_verification?: string;
            fee_recipient?: string;
            builder_selection?: string;
            builder_boost_factor?: string;
            strict_fee_recipient_check?: boolean;
        };
    }, BeaconBlock_17<ForkPostGloas>, ProduceBlockV4Meta>;
    /**
     * Get execution payload envelope.
     * Retrieves execution payload envelope for a given slot and beacon block root.
     * The envelope contains the full execution payload along with associated metadata.
     */
    getExecutionPayloadEnvelope: Endpoint<"GET", {
        /** Slot for which the execution payload envelope is requested */
        slot: Slot_2;
        /** Root of the beacon block that this envelope is for */
        beaconBlockRoot: Root_2;
    }, {
        params: {
            slot: Slot_2;
            beacon_block_root: string;
        };
    }, ts_8.ExecutionPayloadEnvelope, VersionMeta>;
    /**
     * Produce an attestation data
     * Requests that the beacon node produce an AttestationData.
     */
    produceAttestationData: Endpoint<"GET", {
        /** The committee index for which an attestation data should be created */
        committeeIndex?: CommitteeIndex_2;
        /** The slot for which an attestation data should be created */
        slot: Slot_2;
    }, {
        query: {
            slot: number;
            committee_index?: number;
        };
    }, ts.AttestationData, EmptyMeta>;
    /**
     * Produce payload attestation data
     * Requests that the beacon node produce a PayloadAttestationData.
     */
    producePayloadAttestationData: Endpoint<"GET", {
        /** The slot for which payload attestation data should be created */
        slot: Slot_2;
    }, {
        params: {
            slot: Slot_2;
        };
    }, ts_8.PayloadAttestationData, VersionMeta>;
    produceSyncCommitteeContribution: Endpoint<"GET", {
        slot: Slot_2;
        subcommitteeIndex: number;
        beaconBlockRoot: Root_2;
    }, {
        query: {
            slot: number;
            subcommittee_index: number;
            beacon_block_root: string;
        };
    }, ts_2.SyncCommitteeContribution, EmptyMeta>;
    /**
     * Get aggregated attestation
     * Aggregates all attestations matching given attestation data root and slot
     * Returns an aggregated `Attestation` object with same `AttestationData` root.
     */
    getAggregatedAttestation: Endpoint<"GET", {
        /** HashTreeRoot of AttestationData that validator want's aggregated */
        attestationDataRoot: Root_2;
        slot: Slot_2;
    }, {
        query: {
            attestation_data_root: string;
            slot: number;
        };
    }, ts.Attestation, EmptyMeta>;
    /**
     * Get aggregated attestation
     * Aggregates all attestations matching given attestation data root, slot and committee index
     * Returns an aggregated `Attestation` object with same `AttestationData` root.
     */
    getAggregatedAttestationV2: Endpoint<"GET", {
        /** HashTreeRoot of AttestationData that validator want's aggregated */
        attestationDataRoot: Root_2;
        slot: Slot_2;
        committeeIndex: number;
    }, {
        query: {
            attestation_data_root: string;
            slot: number;
            committee_index: number;
        };
    }, Attestation_5, VersionMeta>;
    /**
     * Publish multiple aggregate and proofs
     * Verifies given aggregate and proofs and publishes them on appropriate gossipsub topic.
     */
    publishAggregateAndProofs: Endpoint<"POST", {
        signedAggregateAndProofs: SignedAggregateAndProofListPhase0;
    }, {
        body: unknown;
    }, EmptyResponseData, EmptyMeta>;
    /**
     * Publish multiple aggregate and proofs
     * Verifies given aggregate and proofs and publishes them on appropriate gossipsub topic.
     */
    publishAggregateAndProofsV2: Endpoint<"POST", {
        signedAggregateAndProofs: SignedAggregateAndProofList;
    }, {
        body: unknown;
        headers: {
            [MetaHeader.Version]: string;
        };
    }, EmptyResponseData, EmptyMeta>;
    publishContributionAndProofs: Endpoint<"POST", {
        contributionAndProofs: SignedContributionAndProofList;
    }, {
        body: unknown;
    }, EmptyResponseData, EmptyMeta>;
    /**
     * Signal beacon node to prepare for a committee subnet
     * After beacon node receives this request,
     * search using discv5 for peers related to this subnet
     * and replace current peers with those ones if necessary
     * If validator `is_aggregator`, beacon node must:
     * - announce subnet topic subscription on gossipsub
     * - aggregate attestations received on that subnet
     *
     * Returns if slot signature is valid and beacon node has prepared the attestation subnet.
     *
     * Note that we cannot be certain the Beacon node will find peers for that subnet for various reasons.
     */
    prepareBeaconCommitteeSubnet: Endpoint<"POST", {
        subscriptions: BeaconCommitteeSubscriptionList;
    }, {
        body: unknown;
    }, EmptyResponseData, EmptyMeta>;
    prepareSyncCommitteeSubnets: Endpoint<"POST", {
        subscriptions: SyncCommitteeSubscriptionList;
    }, {
        body: unknown;
    }, EmptyResponseData, EmptyMeta>;
    prepareBeaconProposer: Endpoint<"POST", {
        proposers: ProposerPreparationDataList;
    }, {
        body: unknown;
    }, EmptyResponseData, EmptyMeta>;
    /**
     * Determine if a distributed validator has been selected to aggregate attestations
     *
     * This endpoint is implemented by a distributed validator middleware client to exchange
     * partial beacon committee selection proofs for combined/aggregated selection proofs to allow
     * a validator client to correctly determine if one of its validators has been selected to
     * perform an aggregation duty in this slot.
     *
     * Validator clients running in a distributed validator cluster must query this endpoint
     * at the start of an epoch for the current and lookahead (next) epochs for all validators
     * that have attester duties in the current and lookahead epochs.
     *
     * Note that this endpoint is not implemented by the beacon node and will return a 501 error
     *
     * Returns an array of threshold aggregated beacon committee selection proofs
     */
    submitBeaconCommitteeSelections: Endpoint<"POST", {
        /** An array of partial beacon committee selection proofs */
        selections: BeaconCommitteeSelectionList;
    }, {
        body: unknown;
    }, BeaconCommitteeSelectionList, EmptyMeta>;
    /**
     * Determine if a distributed validator has been selected to make a sync committee contribution
     *
     * This endpoint is implemented by a distributed validator middleware client to exchange
     * partial sync committee selection proofs for combined/aggregated selection proofs to allow
     * a validator client to correctly determine if one of its validators has been selected to
     * perform a sync committee contribution (sync aggregation) duty in this slot.
     *
     * Validator clients running in a distributed validator cluster must query this endpoint
     * at the start of each slot for all validators that are included in the current sync committee.
     *
     * Note that this endpoint is not implemented by the beacon node and will return a 501 error
     *
     * Returns an array of threshold aggregated sync committee selection proofs
     */
    submitSyncCommitteeSelections: Endpoint<"POST", {
        /** An array of partial sync committee selection proofs */
        selections: SyncCommitteeSelectionList;
    }, {
        body: unknown;
    }, SyncCommitteeSelectionList, EmptyMeta>;
    /** Returns validator indices that have been observed to be active on the network */
    getLiveness: Endpoint<"POST", {
        epoch: Epoch;
        indices: ValidatorIndex_2[];
    }, {
        params: {
            epoch: Epoch;
        };
        body: unknown;
    }, LivenessResponseDataList, EmptyMeta>;
    registerValidator: Endpoint<"POST", {
        registrations: SignedValidatorRegistrationV1List;
    }, {
        body: unknown;
    }, EmptyResponseData, EmptyMeta>;
};

declare type Endpoints_2 = block.Endpoints & pool.Endpoints & state.Endpoints & rewards.Endpoints & {
    getGenesis: Endpoint<"GET", EmptyArgs, EmptyRequest, ts.Genesis, EmptyMeta>;
};

declare type Endpoints_3 = {
    /**
     * Get block
     * Retrieves block details for given block id.
     */
    getBlockV2: Endpoint<"GET", BlockArgs, {
        params: {
            block_id: string;
        };
    }, SignedBeaconBlock_17, ExecutionOptimisticFinalizedAndVersionMeta>;
    /**
     * Get blinded block
     * Retrieves blinded block for given block id.
     */
    getBlindedBlock: Endpoint<"GET", BlockArgs, {
        params: {
            block_id: string;
        };
    }, SignedBlindedBeaconBlock_9 | SignedBeaconBlock_17<ForkPreBellatrix>, ExecutionOptimisticFinalizedAndVersionMeta>;
    /**
     * Get block attestations
     * Retrieves attestation included in requested block.
     */
    getBlockAttestations: Endpoint<"GET", BlockArgs, {
        params: {
            block_id: string;
        };
    }, BeaconBlockBody_15<ForkPreElectra>["attestations"], ExecutionOptimisticAndFinalizedMeta>;
    /**
     * Get block attestations
     * Retrieves attestation included in requested block.
     */
    getBlockAttestationsV2: Endpoint<"GET", BlockArgs, {
        params: {
            block_id: string;
        };
    }, BeaconBlockBody_15["attestations"], ExecutionOptimisticFinalizedAndVersionMeta>;
    /**
     * Get block header
     * Retrieves block header for given block id.
     */
    getBlockHeader: Endpoint<"GET", BlockArgs, {
        params: {
            block_id: string;
        };
    }, BlockHeaderResponse, ExecutionOptimisticAndFinalizedMeta>;
    /**
     * Get block headers
     * Retrieves block headers matching given query. By default it will fetch current head slot blocks.
     */
    getBlockHeaders: Endpoint<"GET", {
        slot?: Slot_2;
        parentRoot?: string;
    }, {
        query: {
            slot?: number;
            parent_root?: string;
        };
    }, BlockHeaderResponse[], ExecutionOptimisticAndFinalizedMeta>;
    /**
     * Get block root
     * Retrieves hashTreeRoot of BeaconBlock/BeaconBlockHeader
     */
    getBlockRoot: Endpoint<"GET", BlockArgs, {
        params: {
            block_id: string;
        };
    }, RootResponse, ExecutionOptimisticAndFinalizedMeta>;
    /**
     * Publish a signed block.
     * Instructs the beacon node to broadcast a newly signed beacon block to the beacon network,
     * to be included in the beacon chain. The beacon node is not required to validate the signed
     * `BeaconBlock`, and a successful response (20X) only indicates that the broadcast has been
     * successful. The beacon node is expected to integrate the new block into its state, and
     * therefore validate the block internally, however blocks which fail the validation are still
     * broadcast but a different status code is returned (202)
     *
     * Returns if the block was validated successfully and has been broadcast. It has also been integrated into the beacon node's database.
     */
    publishBlock: Endpoint<"POST", {
        signedBlockContents: SignedBlockContents_7;
    }, {
        body: unknown;
        headers: {
            [MetaHeader.Version]: string;
        };
    }, EmptyResponseData, EmptyMeta>;
    publishBlockV2: Endpoint<"POST", {
        signedBlockContents: SignedBlockContents_7;
        broadcastValidation?: BroadcastValidation;
    }, {
        body: unknown;
        headers: {
            [MetaHeader.Version]: string;
        };
        query: {
            broadcast_validation?: string;
        };
    }, EmptyResponseData, EmptyMeta>;
    /**
     * Publish a signed blinded block by submitting it to the mev relay and patching in the block
     * transactions beacon node gets in response.
     */
    publishBlindedBlock: Endpoint<"POST", {
        signedBlindedBlock: SignedBlindedBeaconBlock_9;
    }, {
        body: unknown;
        headers: {
            [MetaHeader.Version]: string;
        };
    }, EmptyResponseData, EmptyMeta>;
    publishBlindedBlockV2: Endpoint<"POST", {
        signedBlindedBlock: SignedBlindedBeaconBlock_9;
        broadcastValidation?: BroadcastValidation;
    }, {
        body: unknown;
        headers: {
            [MetaHeader.Version]: string;
        };
        query: {
            broadcast_validation?: string;
        };
    }, EmptyResponseData, EmptyMeta>;
    /**
     * Publish signed execution payload envelope.
     * Instructs the beacon node to broadcast a signed execution payload envelope to the network,
     * to be gossiped for payload validation. A success response (20x) indicates that the envelope
     * passed gossip validation and was successfully broadcast onto the network.
     */
    publishExecutionPayloadEnvelope: Endpoint<"POST", {
        signedExecutionPayloadEnvelope: ts_8.SignedExecutionPayloadEnvelope;
    }, {
        body: unknown;
        headers: {
            [MetaHeader.Version]: string;
        };
    }, EmptyResponseData, EmptyMeta>;
    /**
     * Get signed execution payload envelope.
     * Retrieves signed execution payload envelope for a given block id.
     */
    getSignedExecutionPayloadEnvelope: Endpoint<"GET", BlockArgs, {
        params: {
            block_id: string;
        };
    }, ts_8.SignedExecutionPayloadEnvelope, ExecutionOptimisticFinalizedAndVersionMeta>;
    /**
     * Get block BlobSidecar
     * Retrieves BlobSidecar included in requested block.
     */
    getBlobSidecars: Endpoint<"GET", BlockArgs & {
        /**
         * Array of indices for blob sidecars to request for in the specified block.
         * Returns all blob sidecars in the block if not specified.
         */
        indices?: number[];
    }, {
        params: {
            block_id: string;
        };
        query: {
            indices?: number[];
        };
    }, ts_5.BlobSidecars, ExecutionOptimisticFinalizedAndVersionMeta>;
    /**
     * Get blobs
     * Retrieves blobs for a given block id.
     */
    getBlobs: Endpoint<"GET", BlockArgs & {
        /**
         * Array of versioned hashes for blobs to request for in the specified block.
         * Returns all blobs in the block if not specified.
         */
        versionedHashes?: string[];
    }, {
        params: {
            block_id: string;
        };
        query: {
            versioned_hashes?: string[];
        };
    }, ts_5.Blobs, ExecutionOptimisticAndFinalizedMeta>;
};

declare type Endpoints_4 = {
    /**
     * Get Attestations from operations pool
     * Retrieves attestations known by the node but not necessarily incorporated into any block
     */
    getPoolAttestations: Endpoint<"GET", {
        slot?: Slot_2;
        committeeIndex?: CommitteeIndex_2;
    }, {
        query: {
            slot?: number;
            committee_index?: number;
        };
    }, AttestationListPhase0, EmptyMeta>;
    /**
     * Get Attestations from operations pool
     * Retrieves attestations known by the node but not necessarily incorporated into any block
     */
    getPoolAttestationsV2: Endpoint<"GET", {
        slot?: Slot_2;
        committeeIndex?: CommitteeIndex_2;
    }, {
        query: {
            slot?: number;
            committee_index?: number;
        };
    }, AttestationList, VersionMeta>;
    /**
     * Get payload attestations from operations pool
     * Retrieves payload attestations known by the node but not necessarily incorporated into any block.
     */
    getPoolPayloadAttestations: Endpoint<"GET", {
        slot?: Slot_2;
    }, {
        query: {
            slot?: number;
        };
    }, PayloadAttestationList, VersionMeta>;
    /**
     * Get AttesterSlashings from operations pool
     * Retrieves attester slashings known by the node but not necessarily incorporated into any block
     */
    getPoolAttesterSlashings: Endpoint<"GET", EmptyArgs, EmptyRequest, AttesterSlashingListPhase0, EmptyMeta>;
    /**
     * Get AttesterSlashings from operations pool
     * Retrieves attester slashings known by the node but not necessarily incorporated into any block
     */
    getPoolAttesterSlashingsV2: Endpoint<"GET", EmptyArgs, EmptyRequest, AttesterSlashingList, VersionMeta>;
    /**
     * Get ProposerSlashings from operations pool
     * Retrieves proposer slashings known by the node but not necessarily incorporated into any block
     */
    getPoolProposerSlashings: Endpoint<"GET", EmptyArgs, EmptyRequest, ProposerSlashingList, EmptyMeta>;
    /**
     * Get SignedVoluntaryExit from operations pool
     * Retrieves voluntary exits known by the node but not necessarily incorporated into any block
     */
    getPoolVoluntaryExits: Endpoint<"GET", EmptyArgs, EmptyRequest, SignedVoluntaryExitList, EmptyMeta>;
    /**
     * Get SignedBLSToExecutionChange from operations pool
     * Retrieves BLSToExecutionChange known by the node but not necessarily incorporated into any block
     */
    getPoolBLSToExecutionChanges: Endpoint<"GET", EmptyArgs, EmptyRequest, SignedBLSToExecutionChangeList, EmptyMeta>;
    /**
     * Submit Attestation objects to node
     * Submits Attestation objects to the node.  Each attestation in the request body is processed individually.
     *
     * If an attestation is validated successfully the node MUST publish that attestation on the appropriate subnet.
     *
     * If one or more attestations fail validation the node MUST return a 400 error with details of which attestations have failed, and why.
     */
    submitPoolAttestations: Endpoint<"POST", {
        signedAttestations: SingleAttestation_4<ForkPreElectra>[];
    }, {
        body: unknown;
    }, EmptyResponseData, EmptyMeta>;
    /**
     * Submit Attestation objects to node
     * Submits Attestation objects to the node.  Each attestation in the request body is processed individually.
     *
     * If an attestation is validated successfully the node MUST publish that attestation on the appropriate subnet.
     *
     * If one or more attestations fail validation the node MUST return a 400 error with details of which attestations have failed, and why.
     */
    submitPoolAttestationsV2: Endpoint<"POST", {
        signedAttestations: SingleAttestation_4[];
    }, {
        body: unknown;
        headers: {
            [MetaHeader.Version]: string;
        };
    }, EmptyResponseData, EmptyMeta>;
    /**
     * Submit AttesterSlashing object to node's pool
     * Submits AttesterSlashing object to node's pool and if passes validation node MUST broadcast it to network.
     */
    submitPoolAttesterSlashings: Endpoint<"POST", {
        attesterSlashing: ts.AttesterSlashing;
    }, {
        body: unknown;
    }, EmptyResponseData, EmptyMeta>;
    /**
     * Submit AttesterSlashing object to node's pool
     * Submits AttesterSlashing object to node's pool and if passes validation node MUST broadcast it to network.
     */
    submitPoolAttesterSlashingsV2: Endpoint<"POST", {
        attesterSlashing: AttesterSlashing_5;
    }, {
        body: unknown;
        headers: {
            [MetaHeader.Version]: string;
        };
    }, EmptyResponseData, EmptyMeta>;
    /**
     * Submit ProposerSlashing object to node's pool
     * Submits ProposerSlashing object to node's pool and if passes validation  node MUST broadcast it to network.
     */
    submitPoolProposerSlashings: Endpoint<"POST", {
        proposerSlashing: ts.ProposerSlashing;
    }, {
        body: unknown;
    }, EmptyResponseData, EmptyMeta>;
    /**
     * Submit SignedVoluntaryExit object to node's pool
     * Submits SignedVoluntaryExit object to node's pool and if passes validation node MUST broadcast it to network.
     */
    submitPoolVoluntaryExit: Endpoint<"POST", {
        signedVoluntaryExit: ts.SignedVoluntaryExit;
    }, {
        body: unknown;
    }, EmptyResponseData, EmptyMeta>;
    /**
     * Submit SignedBLSToExecutionChange objects to node's pool
     * Submits SignedBLSToExecutionChange objects to node's pool and if passes validation node MUST broadcast it to network.
     */
    submitPoolBLSToExecutionChange: Endpoint<"POST", {
        blsToExecutionChanges: ts_4.SignedBLSToExecutionChange[];
    }, {
        body: unknown;
    }, EmptyResponseData, EmptyMeta>;
    /**
     * Submit SyncCommitteeMessage objects to node's pool
     * Submits SyncCommitteeMessage objects to node's pool and if passes validation node MUST broadcast it to network.
     */
    submitPoolSyncCommitteeSignatures: Endpoint<"POST", {
        signatures: SyncCommitteeMessageList;
    }, {
        body: unknown;
    }, EmptyResponseData, EmptyMeta>;
    /**
     * Submit payload attestation messages
     * Submits payload attestation messages to the beacon node.
     */
    submitPayloadAttestationMessages: Endpoint<"POST", {
        payloadAttestationMessages: PayloadAttestationMessageList;
    }, {
        body: unknown;
        headers: {
            [MetaHeader.Version]: string;
        };
    }, EmptyResponseData, EmptyMeta>;
};

declare type Endpoints_5 = {
    /**
     * Get state SSZ HashTreeRoot
     * Calculates HashTreeRoot for state with given 'stateId'. If stateId is root, same value will be returned.
     */
    getStateRoot: Endpoint<"GET", StateArgs, {
        params: {
            state_id: string;
        };
    }, RootResponse, ExecutionOptimisticAndFinalizedMeta>;
    /**
     * Get Fork object for requested state
     * Returns [Fork](https://github.com/ethereum/consensus-specs/blob/v1.1.10/specs/phase0/beacon-chain.md#fork) object for state with given 'stateId'.
     */
    getStateFork: Endpoint<"GET", StateArgs, {
        params: {
            state_id: string;
        };
    }, ts.Fork, ExecutionOptimisticAndFinalizedMeta>;
    /**
     * Fetch the RANDAO mix for the requested epoch from the state identified by 'stateId'.
     */
    getStateRandao: Endpoint<"GET", StateArgs & {
        /**
         * Fetch randao mix for the given epoch. If an epoch is not specified
         * then the RANDAO mix for the state's current epoch will be returned.
         */
        epoch?: Epoch;
    }, {
        params: {
            state_id: string;
        };
        query: {
            epoch?: number;
        };
    }, RandaoResponse, ExecutionOptimisticAndFinalizedMeta>;
    /**
     * Get state finality checkpoints
     * Returns finality checkpoints for state with given 'stateId'.
     * In case finality is not yet achieved, checkpoint should return epoch 0 and ZERO_HASH as root.
     */
    getStateFinalityCheckpoints: Endpoint<"GET", StateArgs, {
        params: {
            state_id: string;
        };
    }, FinalityCheckpoints, ExecutionOptimisticAndFinalizedMeta>;
    /**
     * Get validator from state by id
     * Returns validator specified by state and id or public key along with status and balance.
     */
    getStateValidator: Endpoint<"GET", StateArgs & {
        /** Either hex encoded public key (with 0x prefix) or validator index */
        validatorId: ValidatorId;
    }, {
        params: {
            state_id: string;
            validator_id: ValidatorId;
        };
    }, ValidatorResponse, ExecutionOptimisticAndFinalizedMeta>;
    /**
     * Get validators from state
     * Returns filterable list of validators with their balance, status and index.
     */
    getStateValidators: Endpoint<"GET", StateArgs & {
        /** Either hex encoded public key (with 0x prefix) or validator index */
        validatorIds?: ValidatorId[];
        /** [Validator status specification](https://hackmd.io/ofFJ5gOmQpu1jjHilHbdQQ) */
        statuses?: ValidatorStatus[];
    }, {
        params: {
            state_id: string;
        };
        query: {
            id?: ValidatorId[];
            status?: ValidatorStatus[];
        };
    }, ValidatorResponseList, ExecutionOptimisticAndFinalizedMeta>;
    /**
     * Get validators from state
     * Returns filterable list of validators with their balance, status and index.
     */
    postStateValidators: Endpoint<"POST", StateArgs & {
        /** Either hex encoded public key (with 0x prefix) or validator index */
        validatorIds?: ValidatorId[];
        /** [Validator status specification](https://hackmd.io/ofFJ5gOmQpu1jjHilHbdQQ) */
        statuses?: ValidatorStatus[];
    }, {
        params: {
            state_id: string;
        };
        body: {
            ids?: string[];
            statuses?: ValidatorStatus[];
        };
    }, ValidatorResponseList, ExecutionOptimisticAndFinalizedMeta>;
    /**
     * Get validator identities from state
     *
     * Returns filterable list of validators identities.
     *
     * Identities will be returned for all indices or public keys that match known validators. If an index or public key does not
     * match any known validator, no identity will be returned but this will not cause an error. There are no guarantees for the
     * returned data in terms of ordering.
     */
    postStateValidatorIdentities: Endpoint<"POST", StateArgs & {
        /** An array of values, with each value either a hex encoded public key (any bytes48 with 0x prefix) or a validator index */
        validatorIds?: ValidatorId[];
    }, {
        params: {
            state_id: string;
        };
        body: string[];
    }, ValidatorIdentities, ExecutionOptimisticAndFinalizedMeta>;
    /**
     * Get validator balances from state
     * Returns filterable list of validator balances.
     */
    getStateValidatorBalances: Endpoint<"GET", StateArgs & {
        /** Either hex encoded public key (with 0x prefix) or validator index */
        validatorIds?: ValidatorId[];
    }, {
        params: {
            state_id: string;
        };
        query: {
            id?: ValidatorId[];
        };
    }, ValidatorBalanceList, ExecutionOptimisticAndFinalizedMeta>;
    /**
     * Get validator balances from state
     * Returns filterable list of validator balances.
     */
    postStateValidatorBalances: Endpoint<"POST", StateArgs & {
        /** Either hex encoded public key (with 0x prefix) or validator index */
        validatorIds?: ValidatorId[];
    }, {
        params: {
            state_id: string;
        };
        body: string[];
    }, ValidatorBalanceList, ExecutionOptimisticAndFinalizedMeta>;
    /**
     * Get all committees for a state.
     * Retrieves the committees for the given state.
     */
    getEpochCommittees: Endpoint<"GET", StateArgs & {
        /** Fetch committees for the given epoch. If not present then the committees for the epoch of the state will be obtained. */
        epoch?: Epoch;
        /** Restrict returned values to those matching the supplied committee index. */
        index?: CommitteeIndex_2;
        /** Restrict returned values to those matching the supplied slot. */
        slot?: Slot_2;
    }, {
        params: {
            state_id: string;
        };
        query: {
            slot?: number;
            epoch?: number;
            index?: number;
        };
    }, EpochCommitteeResponseList, ExecutionOptimisticAndFinalizedMeta>;
    getEpochSyncCommittees: Endpoint<"GET", StateArgs & {
        epoch?: Epoch;
    }, {
        params: {
            state_id: string;
        };
        query: {
            epoch?: number;
        };
    }, EpochSyncCommitteeResponse, ExecutionOptimisticAndFinalizedMeta>;
    /**
     * Get State Pending Deposits
     *
     * Returns pending deposits for state with given 'stateId'.
     */
    getPendingDeposits: Endpoint<"GET", StateArgs, {
        params: {
            state_id: string;
        };
    }, ts_6.PendingDeposits, ExecutionOptimisticFinalizedAndVersionMeta>;
    /**
     * Get State Pending Partial Withdrawals
     *
     * Returns pending partial withdrawals for state with given 'stateId'.
     */
    getPendingPartialWithdrawals: Endpoint<"GET", StateArgs, {
        params: {
            state_id: string;
        };
    }, ts_6.PendingPartialWithdrawals, ExecutionOptimisticFinalizedAndVersionMeta>;
    /**
     * Get State Pending Consolidations
     *
     * Returns pending consolidations for state with given 'stateId'.
     */
    getPendingConsolidations: Endpoint<"GET", StateArgs, {
        params: {
            state_id: string;
        };
    }, ts_6.PendingConsolidations, ExecutionOptimisticFinalizedAndVersionMeta>;
    /**
     * Get State Proposer Lookahead
     *
     * Returns proposer lookahead for state with given 'stateId'.
     */
    getProposerLookahead: Endpoint<"GET", StateArgs, {
        params: {
            state_id: string;
        };
    }, ts_7.ProposerLookahead, ExecutionOptimisticFinalizedAndVersionMeta>;
};

declare type Endpoints_6 = {
    /**
     * Get block rewards
     * Returns the info of rewards received by the block proposer
     */
    getBlockRewards: Endpoint<"GET", BlockArgs, {
        params: {
            block_id: string;
        };
    }, rewards_2.BlockRewards, ExecutionOptimisticAndFinalizedMeta>;
    /**
     * Get attestations rewards
     * Negative values indicate penalties. `inactivity` can only be either 0 or negative number since it is penalty only
     */
    getAttestationsRewards: Endpoint<"POST", {
        /** The epoch to get rewards info from */
        epoch: Epoch;
        /** List of validator indices or pubkeys to filter in */
        validatorIds?: ValidatorId[];
    }, {
        params: {
            epoch: number;
        };
        body: string[];
    }, rewards_2.AttestationsRewards, ExecutionOptimisticAndFinalizedMeta>;
    /**
     * Get sync committee rewards
     * Returns participant reward value for each sync committee member at the given block.
     */
    getSyncCommitteeRewards: Endpoint<"POST", BlockArgs & {
        /** List of validator indices or pubkeys to filter in */
        validatorIds?: ValidatorId[];
    }, {
        params: {
            block_id: string;
        };
        body: string[];
    }, rewards_2.SyncCommitteeRewards, ExecutionOptimisticAndFinalizedMeta>;
};

declare type Endpoints_7 = {
    /**
     * Get deposit contract address.
     * Retrieve Eth1 deposit contract address and chain ID.
     */
    getDepositContract: Endpoint<"GET", EmptyArgs, EmptyRequest, DepositContract, EmptyMeta>;
    /**
     * Get scheduled upcoming forks.
     * Retrieve all scheduled upcoming forks this node is aware of.
     */
    getForkSchedule: Endpoint<"GET", EmptyArgs, EmptyRequest, ForkList, EmptyMeta>;
    /**
     * Retrieve specification configuration used on this node.  The configuration should include:
     *  - Constants for all hard forks known by the beacon node, for example the [phase 0](https://github.com/ethereum/consensus-specs/blob/v1.1.10/specs/phase0/beacon-chain.md#constants) and [altair](https://github.com/ethereum/consensus-specs/blob/v1.1.10/specs/altair/beacon-chain.md#constants) values
     *  - Presets for all hard forks supplied to the beacon node, for example the [phase 0](https://github.com/ethereum/consensus-specs/blob/v1.1.10/presets/mainnet/phase0.yaml) and [altair](https://github.com/ethereum/consensus-specs/blob/v1.1.10/presets/mainnet/altair.yaml) values
     *  - Configuration for the beacon node, for example the [mainnet](https://github.com/ethereum/consensus-specs/blob/v1.1.10/configs/mainnet.yaml) values
     *
     * Values are returned with following format:
     * - any value starting with 0x in the spec is returned as a hex string
     * - numeric values are returned as a quoted integer
     */
    getSpec: Endpoint<"GET", EmptyArgs, EmptyRequest, Spec, EmptyMeta>;
};

declare type Endpoints_8 = {
    /**
     * Retrieves all possible chain heads (leaves of fork choice tree).
     */
    getDebugChainHeadsV2: Endpoint<"GET", EmptyArgs, EmptyRequest, DebugChainHeadList, EmptyMeta>;
    /**
     * Retrieves all current fork choice context
     */
    getDebugForkChoice: Endpoint<"GET", EmptyArgs, EmptyRequest, ForkChoiceResponse, EmptyMeta>;
    /**
     * Dump all ProtoArray's nodes to debug
     */
    getProtoArrayNodes: Endpoint<"GET", EmptyArgs, EmptyRequest, ProtoNodeList, EmptyMeta>;
    /**
     * Get full BeaconState object
     * Returns full BeaconState object for given stateId.
     * Depending on `Accept` header it can be returned either as json or as bytes serialized by SSZ
     */
    getStateV2: Endpoint<"GET", StateArgs, {
        params: {
            state_id: string;
        };
    }, BeaconState_17, ExecutionOptimisticFinalizedAndVersionMeta>;
    /**
     * Get data column sidecars
     * Retrieves data column sidecars for a given block id.
     */
    getDebugDataColumnSidecars: Endpoint<"GET", BlockArgs & {
        /**
         * Array of indices for data column sidecars to request for in the specified block.
         * This endpoint will only return columns that the node is actually custodying.
         * If not specified, returns all data column sidecars that this node is custodying in the block.
         */
        indices?: number[];
    }, {
        params: {
            block_id: string;
        };
        query: {
            indices?: number[];
        };
    }, DataColumnSidecars_5, ExecutionOptimisticFinalizedAndVersionMeta>;
};

declare type Endpoints_9 = {
    /**
     * Subscribe to beacon node events
     * Provides endpoint to subscribe to beacon node Server-Sent-Events stream.
     * Consumers should use [eventsource](https://html.spec.whatwg.org/multipage/server-sent-events.html#the-eventsource-interface)
     * implementation to listen on those events.
     *
     * Returns if SSE stream has been opened.
     */
    eventstream: Endpoint<"GET", EventstreamArgs, {
        query: {
            topics: EventType[];
        };
    }, EmptyResponseData, EmptyMeta>;
};

declare const ENRForkID: ContainerType<{
    forkDigest: ByteVectorType;
    nextForkVersion: ByteVectorType;
    nextForkEpoch: UintNumberType;
}>;

declare type ENRForkID_2 = ValueOf<typeof ssz_2.ENRForkID>;

declare type Epoch = UintNumInf64;

/**
 * Use JS Number for performance, values must be limited to 2**52-1.
 * Epoch is a time unit, so in all usages it's bounded by the clock, ensuring < 2**53-1
 */
declare const Epoch_2: UintNumberType;

declare const EpochAttestations: ListCompositeType<ContainerType<{
    aggregationBits: BitListType;
    data: ContainerType<{
        slot: UintNumberType;
        index: UintNumberType;
        beaconBlockRoot: ByteVectorType;
        source: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
        }>;
        target: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
        }>;
    }>;
    inclusionDelay: UintNumberType;
    proposerIndex: UintNumberType;
}>>;

declare type EpochCommitteeResponse = ValueOf<typeof EpochCommitteeResponseType>;

declare type EpochCommitteeResponseList = ValueOf<typeof EpochCommitteeResponseListType>;

declare const EpochCommitteeResponseListType: ArrayType<Type<ValueOfFields<    {
index: UintNumberType;
slot: UintNumberType;
validators: ArrayType<Type<number>, unknown, unknown>;
}>>, unknown, unknown>;

declare const EpochCommitteeResponseType: ContainerType<{
    index: UintNumberType;
    slot: UintNumberType;
    validators: ArrayType<Type<number>, unknown, unknown>;
}>;

/** Same as @see Epoch + some validator properties must represent 2**52-1 also, which we map to `Infinity` */
declare const EpochInf: UintNumberType;

declare const EpochParticipation: ListBasicType<UintNumberType>;

declare type EpochSyncCommitteeResponse = ValueOf<typeof EpochSyncCommitteeResponseType>;

declare const EpochSyncCommitteeResponseType: ContainerType<{
    /** All of the validator indices in the current sync committee */
    validators: ArrayType<Type<number>, unknown, unknown>;
    /** Subcommittee slices of the current sync committee */
    validatorAggregates: ArrayType<Type<number[]>, unknown, unknown>;
}>;

/** Spec'ed but only used in lodestar as a type */
declare const Eth1Block: ContainerType<{
    timestamp: UintNumberType;
    depositRoot: ByteVectorType;
    depositCount: UintNumberType;
}>;

declare type Eth1Block_2 = ValueOf<typeof ssz_2.Eth1Block>;

declare const Eth1Data: ContainerType<{
    depositRoot: ByteVectorType;
    depositCount: UintNumberType;
    blockHash: ByteVectorType;
}>;

declare type Eth1Data_2 = ValueOf<typeof ssz_2.Eth1Data>;

declare const Eth1DataOrdered: ContainerType<{
    depositRoot: ByteVectorType;
    depositCount: UintNumberType;
    blockHash: ByteVectorType;
    blockNumber: UintNumberType;
}>;

declare type Eth1DataOrdered_2 = ValueOf<typeof ssz_2.Eth1DataOrdered>;

declare const Eth1DataVotes: ListCompositeType<ContainerType<{
    depositRoot: ByteVectorType;
    depositCount: UintNumberType;
    blockHash: ByteVectorType;
}>>;

declare type EventData = {
    [EventType.head]: {
        slot: Slot_2;
        block: RootHex;
        state: RootHex;
        epochTransition: boolean;
        previousDutyDependentRoot: RootHex;
        currentDutyDependentRoot: RootHex;
        executionOptimistic: boolean;
    };
    [EventType.block]: {
        slot: Slot_2;
        block: RootHex;
        executionOptimistic: boolean;
    };
    [EventType.blockGossip]: {
        slot: Slot_2;
        block: RootHex;
    };
    [EventType.attestation]: Attestation_5;
    [EventType.singleAttestation]: ts_6.SingleAttestation;
    [EventType.voluntaryExit]: ts.SignedVoluntaryExit;
    [EventType.proposerSlashing]: ts.ProposerSlashing;
    [EventType.attesterSlashing]: AttesterSlashing_5;
    [EventType.blsToExecutionChange]: ts_4.SignedBLSToExecutionChange;
    [EventType.finalizedCheckpoint]: {
        block: RootHex;
        state: RootHex;
        epoch: Epoch;
        executionOptimistic: boolean;
    };
    [EventType.chainReorg]: {
        slot: Slot_2;
        depth: UintNum64_2;
        oldHeadBlock: RootHex;
        newHeadBlock: RootHex;
        oldHeadState: RootHex;
        newHeadState: RootHex;
        epoch: Epoch;
        executionOptimistic: boolean;
    };
    [EventType.contributionAndProof]: ts_2.SignedContributionAndProof;
    [EventType.lightClientOptimisticUpdate]: {
        version: ForkName;
        data: LightClientOptimisticUpdate_9;
    };
    [EventType.lightClientFinalityUpdate]: {
        version: ForkName;
        data: LightClientFinalityUpdate;
    };
    [EventType.payloadAttributes]: {
        version: ForkName;
        data: SSEPayloadAttributes_11;
    };
    [EventType.blobSidecar]: BlobSidecarSSE;
    [EventType.dataColumnSidecar]: DataColumnSidecarSSE;
    [EventType.executionPayload]: {
        slot: Slot_2;
        builderIndex: BuilderIndex_2;
        blockHash: RootHex;
        blockRoot: RootHex;
        executionOptimistic: boolean;
    };
    [EventType.executionPayloadGossip]: {
        slot: Slot_2;
        builderIndex: BuilderIndex_2;
        blockHash: RootHex;
        blockRoot: RootHex;
    };
    [EventType.executionPayloadAvailable]: {
        slot: Slot_2;
        blockRoot: RootHex;
    };
    [EventType.executionPayloadBid]: {
        version: ForkName;
        data: ts_8.SignedExecutionPayloadBid;
    };
};

declare namespace events {
    export {
        getDefinitions_8 as getDefinitions,
        getTypeByEvent,
        getEventSerdes,
        blobSidecarSSE,
        fuluDataColumnSidecarSSE,
        EventType,
        eventTypes,
        EventData,
        BeaconEvent,
        Endpoints_9 as Endpoints,
        TypeJson
    }
}

declare type EventstreamArgs = {
    /** Event types to subscribe to */
    topics: EventType[];
    signal: AbortSignal;
    onEvent: (event: BeaconEvent) => void;
    onError?: (err: Error) => void;
    onClose?: () => void;
};

declare enum EventType {
    /**
     * The node has finished processing, resulting in a new head. previous_duty_dependent_root is
     * `get_block_root_at_slot(state, compute_start_slot_at_epoch(epoch - 1) - 1)` and
     * current_duty_dependent_root is `get_block_root_at_slot(state, compute_start_slot_at_epoch(epoch) - 1)`.
     * Both dependent roots use the genesis block root in the case of underflow.
     */
    head = "head",
    /** The node has received a block (from P2P or API) that is successfully imported on the fork-choice `on_block` handler */
    block = "block",
    /** The node has received a block (from P2P or API) that passes validation rules of the `beacon_block` topic */
    blockGossip = "block_gossip",
    /** The node has received a valid attestation (from P2P or API) */
    attestation = "attestation",
    /** The node has received a valid SingleAttestation (from P2P or API) */
    singleAttestation = "single_attestation",
    /** The node has received a valid voluntary exit (from P2P or API) */
    voluntaryExit = "voluntary_exit",
    /** The node has received a valid proposer slashing (from P2P or API) */
    proposerSlashing = "proposer_slashing",
    /** The node has received a valid attester slashing (from P2P or API) */
    attesterSlashing = "attester_slashing",
    /** The node has received a valid blsToExecutionChange (from P2P or API) */
    blsToExecutionChange = "bls_to_execution_change",
    /** Finalized checkpoint has been updated */
    finalizedCheckpoint = "finalized_checkpoint",
    /** The node has reorganized its chain */
    chainReorg = "chain_reorg",
    /** The node has received a valid sync committee SignedContributionAndProof (from P2P or API) */
    contributionAndProof = "contribution_and_proof",
    /** New or better optimistic header update available */
    lightClientOptimisticUpdate = "light_client_optimistic_update",
    /** New or better finality update available */
    lightClientFinalityUpdate = "light_client_finality_update",
    /** Payload attributes for block proposal */
    payloadAttributes = "payload_attributes",
    /** The node has received a valid BlobSidecar (from P2P or API) */
    blobSidecar = "blob_sidecar",
    /** The node has received a valid DataColumnSidecar (from P2P or API) */
    dataColumnSidecar = "data_column_sidecar",
    /** The node has received a `SignedExecutionPayloadEnvelope` (from P2P or API) that is successfully imported on the fork-choice `on_execution_payload` handler */
    executionPayload = "execution_payload",
    /** The node has received a `SignedExecutionPayloadEnvelope` (from P2P or API) that passes validation rules of the `execution_payload` topic */
    executionPayloadGossip = "execution_payload_gossip",
    /** The node has verified that the execution payload and blobs for a block are available and ready for payload attestation */
    executionPayloadAvailable = "execution_payload_available",
    /** The node has received a `SignedExecutionPayloadBid` (from P2P or API) that passes gossip validation on the `execution_payload_bid` topic */
    executionPayloadBid = "execution_payload_bid"
}

declare const eventTypes: {
    [K in EventType]: K;
};

declare const ExecutionAddress: ExecutionAddressType;

declare class ExecutionAddressType extends ByteVectorType {
    constructor();
    toJson(value: ByteVector): unknown;
}

declare const ExecutionBranch: VectorCompositeType<ByteVectorType>;

declare type ExecutionOptimisticAndDependentRootMeta = ValueOf<typeof ExecutionOptimisticAndDependentRootType>;

declare const ExecutionOptimisticAndDependentRootType: ContainerType<{
    /**
     * True if the response references an unverified execution payload.
     * Optimistic information may be invalidated at a later time.
     */
    executionOptimistic: BooleanType;
    /**
     * The block root that this response is dependent on
     */
    dependentRoot: StringType<string>;
}>;

declare type ExecutionOptimisticAndFinalizedMeta = ValueOf<typeof ExecutionOptimisticAndFinalizedType>;

declare const ExecutionOptimisticAndFinalizedType: ContainerType<{
    /**
     * True if the response references an unverified execution payload.
     * Optimistic information may be invalidated at a later time.
     */
    executionOptimistic: BooleanType;
    /**
     * True if the response references the finalized history of the chain, as determined by fork choice
     */
    finalized: BooleanType;
}>;

declare type ExecutionOptimisticFinalizedAndVersionMeta = ValueOf<typeof ExecutionOptimisticFinalizedAndVersionType>;

declare const ExecutionOptimisticFinalizedAndVersionType: ContainerType<{
    /**
     * Fork code name
     */
    version: StringType<ForkName>;
    /**
     * True if the response references an unverified execution payload.
     * Optimistic information may be invalidated at a later time.
     */
    executionOptimistic: BooleanType;
    /**
     * True if the response references the finalized history of the chain, as determined by fork choice
     */
    finalized: BooleanType;
}>;

declare type ExecutionOptimisticMeta = ValueOf<typeof ExecutionOptimisticType>;

declare const ExecutionOptimisticType: ContainerType<{
    /**
     * True if the response references an unverified execution payload.
     * Optimistic information may be invalidated at a later time.
     */
    executionOptimistic: BooleanType;
}>;

declare const ExecutionPayload: ContainerType<{
    parentHash: ByteVectorType;
    feeRecipient: ExecutionAddressType;
    stateRoot: ByteVectorType;
    receiptsRoot: ByteVectorType;
    logsBloom: ByteVectorType;
    prevRandao: ByteVectorType;
    blockNumber: UintNumberType;
    gasLimit: UintNumberType;
    gasUsed: UintNumberType;
    timestamp: UintNumberType;
    extraData: ByteListType;
    baseFeePerGas: UintBigintType;
    blockHash: ByteVectorType;
    transactions: ListCompositeType<ByteListType>;
}>;

declare type ExecutionPayload_10 = ValueOf<typeof ssz_9.ExecutionPayload>;

declare type ExecutionPayload_2 = ValueOf<typeof ssz_4.ExecutionPayload>;

declare const ExecutionPayload_3: ContainerType<{
    parentHash: ByteVectorType;
    feeRecipient: ExecutionAddressType;
    stateRoot: ByteVectorType;
    receiptsRoot: ByteVectorType;
    logsBloom: ByteVectorType;
    prevRandao: ByteVectorType;
    blockNumber: UintNumberType;
    gasLimit: UintNumberType;
    gasUsed: UintNumberType;
    timestamp: UintNumberType;
    extraData: ByteListType;
    baseFeePerGas: UintBigintType;
    blockHash: ByteVectorType;
    transactions: ListCompositeType<ByteListType>;
    withdrawals: ListCompositeType<ContainerType<{
        index: UintNumberType;
        validatorIndex: UintNumberType;
        address: ExecutionAddressType;
        amount: UintBigintType;
    }>>;
}>;

declare type ExecutionPayload_4 = ValueOf<typeof ssz_5.ExecutionPayload>;

declare const ExecutionPayload_5: ContainerType<{
    parentHash: ByteVectorType;
    feeRecipient: ExecutionAddressType;
    stateRoot: ByteVectorType;
    receiptsRoot: ByteVectorType;
    logsBloom: ByteVectorType;
    prevRandao: ByteVectorType;
    blockNumber: UintNumberType;
    gasLimit: UintNumberType;
    gasUsed: UintNumberType;
    timestamp: UintNumberType;
    extraData: ByteListType;
    baseFeePerGas: UintBigintType;
    blockHash: ByteVectorType;
    transactions: ListCompositeType<ByteListType>;
    withdrawals: ListCompositeType<ContainerType<{
        index: UintNumberType;
        validatorIndex: UintNumberType;
        address: ExecutionAddressType;
        amount: UintBigintType;
    }>>;
    blobGasUsed: UintBigintType;
    excessBlobGas: UintBigintType;
}>;

declare type ExecutionPayload_6 = ValueOf<typeof ssz_6.ExecutionPayload>;

declare const ExecutionPayload_7: ContainerType<{
    parentHash: ByteVectorType;
    feeRecipient: ExecutionAddressType;
    stateRoot: ByteVectorType;
    receiptsRoot: ByteVectorType;
    logsBloom: ByteVectorType;
    prevRandao: ByteVectorType;
    blockNumber: UintNumberType;
    gasLimit: UintNumberType;
    gasUsed: UintNumberType;
    timestamp: UintNumberType;
    extraData: ByteListType;
    baseFeePerGas: UintBigintType;
    blockHash: ByteVectorType;
    transactions: ListCompositeType<ByteListType>;
    withdrawals: ListCompositeType<ContainerType<{
        index: UintNumberType;
        validatorIndex: UintNumberType;
        address: ExecutionAddressType;
        amount: UintBigintType;
    }>>;
    blobGasUsed: UintBigintType;
    excessBlobGas: UintBigintType;
}>;

declare type ExecutionPayload_8 = ValueOf<typeof ssz_7.ExecutionPayload>;

declare const ExecutionPayload_9: ContainerType<{
    parentHash: ByteVectorType;
    feeRecipient: ExecutionAddressType;
    stateRoot: ByteVectorType;
    receiptsRoot: ByteVectorType;
    logsBloom: ByteVectorType;
    prevRandao: ByteVectorType;
    blockNumber: UintNumberType;
    gasLimit: UintNumberType;
    gasUsed: UintNumberType;
    timestamp: UintNumberType;
    extraData: ByteListType;
    baseFeePerGas: UintBigintType;
    blockHash: ByteVectorType;
    transactions: ListCompositeType<ByteListType>;
    withdrawals: ListCompositeType<ContainerType<{
        index: UintNumberType;
        validatorIndex: UintNumberType;
        address: ExecutionAddressType;
        amount: UintBigintType;
    }>>;
    blobGasUsed: UintBigintType;
    excessBlobGas: UintBigintType;
    blockAccessList: ByteListType;
    slotNumber: UintNumberType;
}>;

declare const ExecutionPayloadAndBlobsBundle: ContainerType<{
    executionPayload: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactions: ListCompositeType<ByteListType>;
        withdrawals: ListCompositeType<ContainerType<{
            index: UintNumberType;
            validatorIndex: UintNumberType;
            address: ExecutionAddressType;
            amount: UintBigintType;
        }>>;
        blobGasUsed: UintBigintType;
        excessBlobGas: UintBigintType;
    }>;
    blobsBundle: ContainerType<{
        commitments: ListCompositeType<ByteVectorType>;
        proofs: ListCompositeType<ByteVectorType>;
        blobs: ListCompositeType<ByteVectorType>;
    }>;
}>;

declare type ExecutionPayloadAndBlobsBundle_2 = ValueOf<typeof ssz_6.ExecutionPayloadAndBlobsBundle>;

declare const ExecutionPayloadAndBlobsBundle_3: ContainerType<{
    executionPayload: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactions: ListCompositeType<ByteListType>;
        withdrawals: ListCompositeType<ContainerType<{
            index: UintNumberType;
            validatorIndex: UintNumberType;
            address: ExecutionAddressType;
            amount: UintBigintType;
        }>>;
        blobGasUsed: UintBigintType;
        excessBlobGas: UintBigintType;
    }>;
    blobsBundle: ContainerType<{
        commitments: ListCompositeType<ByteVectorType>;
        proofs: ListCompositeType<ByteVectorType>;
        blobs: ListCompositeType<ByteVectorType>;
    }>;
}>;

declare type ExecutionPayloadAndBlobsBundle_4 = ValueOf<typeof ssz_8.ExecutionPayloadAndBlobsBundle>;

declare const ExecutionPayloadBid: ContainerType<{
    parentBlockHash: ByteVectorType;
    parentBlockRoot: ByteVectorType;
    blockHash: ByteVectorType;
    prevRandao: ByteVectorType;
    feeRecipient: ExecutionAddressType;
    gasLimit: UintBigintType;
    builderIndex: UintNumberType;
    slot: UintNumberType;
    value: UintNumberType;
    executionPayment: UintNumberType;
    blobKzgCommitments: ListCompositeType<ByteVectorType>;
    executionRequestsRoot: ByteVectorType;
}>;

declare type ExecutionPayloadBid_2 = ValueOf<typeof ssz_9.ExecutionPayloadBid>;

declare const ExecutionPayloadEnvelope: ContainerType<{
    payload: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactions: ListCompositeType<ByteListType>;
        withdrawals: ListCompositeType<ContainerType<{
            index: UintNumberType;
            validatorIndex: UintNumberType;
            address: ExecutionAddressType;
            amount: UintBigintType;
        }>>;
        blobGasUsed: UintBigintType;
        excessBlobGas: UintBigintType;
        blockAccessList: ByteListType;
        slotNumber: UintNumberType;
    }>;
    executionRequests: ContainerType<{
        deposits: ListCompositeType<ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            index: UintBigintType;
        }>>;
        withdrawals: ListCompositeType<ContainerType<{
            sourceAddress: ExecutionAddressType;
            validatorPubkey: ByteVectorType;
            amount: UintBigintType;
        }>>;
        consolidations: ListCompositeType<ContainerType<{
            sourceAddress: ExecutionAddressType;
            sourcePubkey: ByteVectorType;
            targetPubkey: ByteVectorType;
        }>>;
    }>;
    builderIndex: UintNumberType;
    beaconBlockRoot: ByteVectorType;
    parentBeaconBlockRoot: ByteVectorType;
}>;

declare type ExecutionPayloadEnvelope_2 = ValueOf<typeof ssz_9.ExecutionPayloadEnvelope>;

declare const ExecutionPayloadEnvelopesByRangeRequest: ContainerType<{
    startSlot: UintNumberType;
    count: UintNumberType;
}>;

declare type ExecutionPayloadEnvelopesByRangeRequest_2 = ValueOf<typeof ssz_9.ExecutionPayloadEnvelopesByRangeRequest>;

declare const ExecutionPayloadHeader: ContainerType<{
    parentHash: ByteVectorType;
    feeRecipient: ExecutionAddressType;
    stateRoot: ByteVectorType;
    receiptsRoot: ByteVectorType;
    logsBloom: ByteVectorType;
    prevRandao: ByteVectorType;
    blockNumber: UintNumberType;
    gasLimit: UintNumberType;
    gasUsed: UintNumberType;
    timestamp: UintNumberType;
    extraData: ByteListType;
    baseFeePerGas: UintBigintType;
    blockHash: ByteVectorType;
    transactionsRoot: ByteVectorType;
}>;

declare type ExecutionPayloadHeader_2 = ValueOf<typeof ssz_4.ExecutionPayloadHeader>;

declare const ExecutionPayloadHeader_3: ContainerType<{
    parentHash: ByteVectorType;
    feeRecipient: ExecutionAddressType;
    stateRoot: ByteVectorType;
    receiptsRoot: ByteVectorType;
    logsBloom: ByteVectorType;
    prevRandao: ByteVectorType;
    blockNumber: UintNumberType;
    gasLimit: UintNumberType;
    gasUsed: UintNumberType;
    timestamp: UintNumberType;
    extraData: ByteListType;
    baseFeePerGas: UintBigintType;
    blockHash: ByteVectorType;
    transactionsRoot: ByteVectorType;
    withdrawalsRoot: ByteVectorType;
}>;

declare type ExecutionPayloadHeader_4 = ValueOf<typeof ssz_5.ExecutionPayloadHeader>;

declare const ExecutionPayloadHeader_5: ContainerType<{
    parentHash: ByteVectorType;
    feeRecipient: ExecutionAddressType;
    stateRoot: ByteVectorType;
    receiptsRoot: ByteVectorType;
    logsBloom: ByteVectorType;
    prevRandao: ByteVectorType;
    blockNumber: UintNumberType;
    gasLimit: UintNumberType;
    gasUsed: UintNumberType;
    timestamp: UintNumberType;
    extraData: ByteListType;
    baseFeePerGas: UintBigintType;
    blockHash: ByteVectorType;
    transactionsRoot: ByteVectorType;
    withdrawalsRoot: ByteVectorType;
    blobGasUsed: UintBigintType;
    excessBlobGas: UintBigintType;
}>;

declare type ExecutionPayloadHeader_6 = ValueOf<typeof ssz_6.ExecutionPayloadHeader>;

declare const ExecutionPayloadHeader_7: ContainerType<{
    parentHash: ByteVectorType;
    feeRecipient: ExecutionAddressType;
    stateRoot: ByteVectorType;
    receiptsRoot: ByteVectorType;
    logsBloom: ByteVectorType;
    prevRandao: ByteVectorType;
    blockNumber: UintNumberType;
    gasLimit: UintNumberType;
    gasUsed: UintNumberType;
    timestamp: UintNumberType;
    extraData: ByteListType;
    baseFeePerGas: UintBigintType;
    blockHash: ByteVectorType;
    transactionsRoot: ByteVectorType;
    withdrawalsRoot: ByteVectorType;
    blobGasUsed: UintBigintType;
    excessBlobGas: UintBigintType;
}>;

declare type ExecutionPayloadHeader_8 = ValueOf<typeof ssz_7.ExecutionPayloadHeader>;

declare const ExecutionRequests: ContainerType<{
    deposits: ListCompositeType<ContainerType<{
        pubkey: ByteVectorType;
        withdrawalCredentials: ByteVectorType;
        amount: UintNumberType;
        signature: ByteVectorType;
        index: UintBigintType;
    }>>;
    withdrawals: ListCompositeType<ContainerType<{
        sourceAddress: ExecutionAddressType;
        validatorPubkey: ByteVectorType;
        amount: UintBigintType;
    }>>;
    consolidations: ListCompositeType<ContainerType<{
        sourceAddress: ExecutionAddressType;
        sourcePubkey: ByteVectorType;
        targetPubkey: ByteVectorType;
    }>>;
}>;

declare type ExecutionRequests_2 = ValueOf<typeof ssz_7.ExecutionRequests>;

declare const ExtendedMatrix: ListCompositeType<ByteVectorType>;

declare type ExtendedMatrix_2 = ValueOf<typeof ssz_8.ExtendedMatrix>;

/** Lodestar-specific (non-standardized) options */
declare type ExtraProduceBlockOpts = {
    feeRecipient?: string;
    builderSelection?: BuilderSelection;
    strictFeeRecipientCheck?: boolean;
    blindedLocal?: boolean;
};

declare type ExtraRequestInit = {
    /** Wire format to use in HTTP requests to server */
    requestWireFormat?: `${WireFormat}`;
    /** Preferred wire format for HTTP responses from server */
    responseWireFormat?: `${WireFormat}`;
    /** Timeout of requests in milliseconds */
    timeoutMs?: number;
    /** Number of retries per request */
    retries?: number;
    /** Retry delay, only relevant if retries > 0 */
    retryDelay?: number;
};

declare type FieldEntry<Fields extends Record<string, Type<unknown>>> = {
    fieldName: keyof Fields;
    fieldType: Fields[keyof Fields];
    jsonKey: string;
    gindex: Gindex;
};

declare type FieldsView<Fields extends Record<string, Type<unknown>>> = {
    [K in keyof Fields]: Fields[K] extends CompositeType<unknown, infer TV, unknown> ? TV : Fields[K] extends BasicType<infer V> ? V : never;
};

declare type FieldsViewDU<Fields extends Record<string, Type<unknown>>> = {
    [K in keyof Fields]: Fields[K] extends CompositeType<unknown, unknown, infer TVDU> ? TVDU : Fields[K] extends BasicType<infer V> ? V : never;
};

declare type FilterGetPeers = {
    state?: PeerState[];
    direction?: PeerDirection[];
};

declare const FinalityBranch: VectorCompositeType<ByteVectorType>;

declare const FinalityBranch_2: VectorCompositeType<ByteVectorType>;

declare type FinalityCheckpoints = ValueOf<typeof FinalityCheckpointsType>;

declare const FinalityCheckpointsType: ContainerType<{
    previousJustified: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
    currentJustified: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
    finalized: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
}>;

declare const Fork: ContainerType<{
    previousVersion: ByteVectorType;
    currentVersion: ByteVectorType;
    epoch: UintNumberType;
}>;

declare type Fork_2 = ValueOf<typeof ssz_2.Fork>;

declare type ForkAll = ForkName;

/**
 * Fork boundaries include both normal hard-forks (phase0, altair, etc.)
 * and Blob Parameter Only (BPO) forks and are used to un-/subscribe to gossip topics
 * and compute the fork digest primarily for domain separation on the p2p layer.
 */
declare type ForkBoundary = {
    fork: ForkName;
    epoch: Epoch;
};

declare type ForkChoiceResponse = ValueOf<typeof ForkChoiceResponseType>;

declare const ForkChoiceResponseType: ContainerType<{
    justifiedCheckpoint: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
    finalizedCheckpoint: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
    }>;
    forkChoiceNodes: ArrayType<Type<ValueOfFields<    {
    slot: UintNumberType;
    blockRoot: StringType<string>;
    parentRoot: StringType<string>;
    justifiedEpoch: UintNumberType;
    finalizedEpoch: UintNumberType;
    weight: UintNumberType;
    validity: StringType<"invalid" | "optimistic" | "valid">;
    executionBlockHash: StringType<string>;
    }>>, unknown, unknown>;
}>;

/**
 * Fork schedule and helper methods
 */
declare type ForkConfig = {
    /** Forks in order order of occurence, `phase0` first */
    forks: {
        [K in ForkName]: ForkInfo;
    };
    forksAscendingEpochOrder: ForkInfo[];
    forksDescendingEpochOrder: ForkInfo[];
    forkBoundariesAscendingEpochOrder: ForkBoundary[];
    forkBoundariesDescendingEpochOrder: ForkBoundary[];
    /** Get the hard-fork info for the active fork at `slot` */
    getForkInfo(slot: Slot_2): ForkInfo;
    /** Get the hard-fork info for the active fork at `epoch` */
    getForkInfoAtEpoch(epoch: Epoch): ForkInfo;
    /** Get the active fork boundary at a given `epoch` */
    getForkBoundaryAtEpoch(epoch: Epoch): ForkBoundary;
    /** Get the hard-fork name at a given slot */
    getForkName(slot: Slot_2): ForkName;
    /** Get the hard-fork sequence number at a given slot */
    getForkSeq(slot: Slot_2): ForkSeq;
    /** Get the hard-fork sequence number at a given epoch */
    getForkSeqAtEpoch(epoch: Epoch): ForkSeq;
    /** Get the hard-fork version at a given slot */
    getForkVersion(slot: Slot_2): Version_2;
    /** Get SSZ types by hard-fork */
    getForkTypes<F extends ForkName = ForkAll>(slot: Slot_2): SSZTypesFor<F>;
    /** Get post-altair SSZ types by hard-fork*/
    getPostAltairForkTypes(slot: Slot_2): SSZTypesFor<ForkPostAltair>;
    /** Get post-bellatrix SSZ types by hard-fork*/
    getPostBellatrixForkTypes(slot: Slot_2): SSZTypesFor<ForkPostBellatrix>;
    /** Get post-deneb SSZ types by hard-fork*/
    getPostDenebForkTypes(slot: Slot_2): SSZTypesFor<ForkPostDeneb>;
    /** Get max blobs per block at a given epoch */
    getMaxBlobsPerBlock(epoch: Epoch): number;
    /** Get blob parameters at a given epoch */
    getBlobParameters(epoch: Epoch): BlobParameters;
    getAttestationDueMs(fork: ForkName): number;
    getAggregateDueMs(fork: ForkName): number;
    getSyncMessageDueMs(fork: ForkName): number;
    getSyncContributionDueMs(fork: ForkName): number;
    getProposerReorgCutoffMs(fork: ForkName): number;
    /** Convert basis points to milliseconds into the slot */
    getSlotComponentDurationMs(basisPoints: number): number;
};

declare const ForkData: ContainerType<{
    currentVersion: ByteVectorType;
    genesisValidatorsRoot: ByteVectorType;
}>;

declare type ForkData_2 = ValueOf<typeof ssz_2.ForkData>;

declare const ForkDigest: ByteVectorType;

declare type ForkDigest_2 = Bytes4_2;

declare type ForkDigestContext = {
    forkDigest2ForkBoundary(forkDigest: ForkDigest_2 | ForkDigestHex): ForkBoundary;
    forkDigest2ForkBoundaryOption(forkDigest: ForkDigest_2 | ForkDigestHex): ForkBoundary | null;
    forkBoundary2ForkDigest(boundary: ForkBoundary): ForkDigest_2;
    forkBoundary2ForkDigestHex(boundary: ForkBoundary): ForkDigestHex;
};

declare type ForkDigestHex = string;

declare type ForkInfo = {
    name: ForkName;
    seq: ForkSeq;
    epoch: Epoch;
    version: Version_2;
    prevVersion: Version_2;
    prevForkName: ForkName;
};

declare type ForkList = ValueOf<typeof ForkListType>;

declare const ForkListType: ArrayType<Type<ValueOfFields<    {
previousVersion: ByteVectorType;
currentVersion: ByteVectorType;
epoch: UintNumberType;
}>>, unknown, unknown>;

/**
 * Fork code name in order of occurrence
 */
declare enum ForkName {
    phase0 = "phase0",
    altair = "altair",
    bellatrix = "bellatrix",
    capella = "capella",
    deneb = "deneb",
    electra = "electra",
    fulu = "fulu",
    gloas = "gloas"
}

declare type ForkPostAltair = Exclude<ForkName, ForkPreAltair>;

declare type ForkPostBellatrix = Exclude<ForkName, ForkPreBellatrix>;

declare type ForkPostDeneb = Exclude<ForkName, ForkPreDeneb>;

declare type ForkPostFulu = Exclude<ForkName, ForkPreFulu>;

declare type ForkPostGloas = Exclude<ForkName, ForkPreGloas>;

declare type ForkPreAltair = ForkName.phase0;

declare type ForkPreBellatrix = ForkPreAltair | ForkName.altair;

declare type ForkPreCapella = ForkPreBellatrix | ForkName.bellatrix;

declare type ForkPreDeneb = ForkPreCapella | ForkName.capella;

declare type ForkPreElectra = ForkPreDeneb | ForkName.deneb;

declare type ForkPreFulu = ForkPreElectra | ForkName.electra;

declare type ForkPreGloas = ForkPreFulu | ForkName.fulu;

/**
 * Fork sequence number in order of occurrence
 */
declare enum ForkSeq {
    phase0 = 0,
    altair = 1,
    bellatrix = 2,
    capella = 3,
    deneb = 4,
    electra = 5,
    fulu = 6,
    gloas = 7
}

declare type FullOrBlindedExecutionPayload = ExecutionPayload_2 | ExecutionPayloadHeader_2;

declare type FullOrBlindedExecutionPayload_2 = ExecutionPayload_4 | ExecutionPayloadHeader_4;

declare type FullOrBlindedExecutionPayload_3 = ExecutionPayload_6 | ExecutionPayloadHeader_6;

declare type FuluDataColumnSidecarSSE = ValueOf<typeof fuluDataColumnSidecarSSE>;

declare const fuluDataColumnSidecarSSE: ContainerType<{
    blockRoot: StringType<string>;
    index: UintNumberType;
    slot: UintNumberType;
    kzgCommitments: ListBasicType<StringType<string>>;
}>;

declare const G1Point: ByteVectorType;

declare const G2Point: ByteVectorType;

declare const Genesis: ContainerType<{
    genesisValidatorsRoot: ByteVectorType;
    genesisTime: UintNumberType;
    genesisForkVersion: ByteVectorType;
}>;

declare type Genesis_2 = ValueOf<typeof ssz_2.Genesis>;

export declare type GenesisData = {
    genesisTime: number;
    genesisValidatorsRoot: RootHex | Uint8Array;
};

declare function getApiFromUrl(url: string, network: NetworkName, init?: ApiRequestInit): ApiClient;

declare function getChainForkConfigFromNetwork(network: NetworkName): ChainForkConfig;

/**
 * With `console` module and ignoring debug logs
 */
declare function getConsoleLogger(opts?: {
    logDebug?: boolean;
}): ILcLogger;

declare function getContainerTreeViewClass<Fields extends Record<string, Type<unknown>>>(type: ContainerTypeGeneric<Fields>): ContainerTreeViewTypeConstructor<Fields>;

declare function getContainerTreeViewDUClass<Fields extends Record<string, Type<unknown>>>(type: ContainerTypeGeneric<Fields>): ContainerTreeViewDUTypeConstructor<Fields>;

declare function getCurrentSlot(config: ChainConfig, genesisTime: number): Slot_2;

declare function getDefinitions(config: ChainForkConfig): RouteDefinitions<Endpoints_3>;

declare function getDefinitions_10(config: ChainForkConfig): RouteDefinitions<Endpoints_11>;

declare function getDefinitions_11(_config: ChainForkConfig): RouteDefinitions<Endpoints_12>;

declare function getDefinitions_12(_config: ChainForkConfig): RouteDefinitions<Endpoints_13>;

declare function getDefinitions_13(config: ChainForkConfig): RouteDefinitions<Endpoints_14>;

declare function getDefinitions_2(config: ChainForkConfig): RouteDefinitions<Endpoints_4>;

declare function getDefinitions_3(_config: ChainForkConfig): RouteDefinitions<Endpoints_5>;

declare function getDefinitions_4(_config: ChainForkConfig): RouteDefinitions<Endpoints_6>;

declare function getDefinitions_5(config: ChainForkConfig): RouteDefinitions<Endpoints_2>;

declare function getDefinitions_6(_config: ChainForkConfig): RouteDefinitions<Endpoints_7>;

declare function getDefinitions_7(_config: ChainForkConfig): RouteDefinitions<Endpoints_8>;

declare function getDefinitions_8(_config: ChainForkConfig): RouteDefinitions<Endpoints_9>;

declare function getDefinitions_9(config: ChainForkConfig): RouteDefinitions<Endpoints_10>;

declare function getEventSerdes(config: ChainForkConfig): {
    toJson: (event: BeaconEvent) => unknown;
    fromJson: (type: EventType, data: unknown) => ValueOfFields<    {
    message: ContainerType<{
    aggregatorIndex: UintNumberType;
    contribution: ContainerType<{
    slot: UintNumberType;
    beaconBlockRoot: ByteVectorType;
    subcommitteeIndex: UintNumberType;
    aggregationBits: BitVectorType;
    signature: ByteVectorType;
    }>;
    selectionProof: ByteVectorType;
    }>;
    signature: ByteVectorType;
    }> | ValueOfFields<    {
    message: ContainerType<{
    validatorIndex: UintNumberType;
    fromBlsPubkey: ByteVectorType;
    toExecutionAddress: ExecutionAddressType;
    }>;
    signature: ByteVectorType;
    }> | ValueOfFields<    {
    aggregationBits: BitListType;
    data: ContainerType<{
    slot: UintNumberType;
    index: UintNumberType;
    beaconBlockRoot: ByteVectorType;
    source: ContainerType<{
    epoch: UintNumberType;
    root: ByteVectorType;
    }>;
    target: ContainerType<{
    epoch: UintNumberType;
    root: ByteVectorType;
    }>;
    }>;
    signature: ByteVectorType;
    committeeBits: BitVectorType;
    }> | ValueOfFields<    {
    committeeIndex: UintNumberType;
    attesterIndex: UintNumberType;
    data: ContainerType<{
    slot: UintNumberType;
    index: UintNumberType;
    beaconBlockRoot: ByteVectorType;
    source: ContainerType<{
    epoch: UintNumberType;
    root: ByteVectorType;
    }>;
    target: ContainerType<{
    epoch: UintNumberType;
    root: ByteVectorType;
    }>;
    }>;
    signature: ByteVectorType;
    }> | ValueOfFields<    {
    attestation1: ContainerType<{
    attestingIndices: ListBasicType<UintNumberType>;
    data: ContainerType<{
    slot: UintBigintType;
    index: UintBigintType;
    beaconBlockRoot: ByteVectorType;
    source: ContainerType<{
    epoch: UintBigintType;
    root: ByteVectorType;
    }>;
    target: ContainerType<{
    epoch: UintBigintType;
    root: ByteVectorType;
    }>;
    }>;
    signature: ByteVectorType;
    }>;
    attestation2: ContainerType<{
    attestingIndices: ListBasicType<UintNumberType>;
    data: ContainerType<{
    slot: UintBigintType;
    index: UintBigintType;
    beaconBlockRoot: ByteVectorType;
    source: ContainerType<{
    epoch: UintBigintType;
    root: ByteVectorType;
    }>;
    target: ContainerType<{
    epoch: UintBigintType;
    root: ByteVectorType;
    }>;
    }>;
    signature: ByteVectorType;
    }>;
    }> | ValueOfFields<    {
    aggregationBits: BitListType;
    data: ContainerType<{
    slot: UintNumberType;
    index: UintNumberType;
    beaconBlockRoot: ByteVectorType;
    source: ContainerType<{
    epoch: UintNumberType;
    root: ByteVectorType;
    }>;
    target: ContainerType<{
    epoch: UintNumberType;
    root: ByteVectorType;
    }>;
    }>;
    signature: ByteVectorType;
    }> | ValueOfFields<    {
    attestation1: ContainerType<{
    attestingIndices: ListBasicType<UintNumberType>;
    data: ContainerType<{
    slot: UintBigintType;
    index: UintBigintType;
    beaconBlockRoot: ByteVectorType;
    source: ContainerType<{
    epoch: UintBigintType;
    root: ByteVectorType;
    }>;
    target: ContainerType<{
    epoch: UintBigintType;
    root: ByteVectorType;
    }>;
    }>;
    signature: ByteVectorType;
    }>;
    attestation2: ContainerType<{
    attestingIndices: ListBasicType<UintNumberType>;
    data: ContainerType<{
    slot: UintBigintType;
    index: UintBigintType;
    beaconBlockRoot: ByteVectorType;
    source: ContainerType<{
    epoch: UintBigintType;
    root: ByteVectorType;
    }>;
    target: ContainerType<{
    epoch: UintBigintType;
    root: ByteVectorType;
    }>;
    }>;
    signature: ByteVectorType;
    }>;
    }> | ValueOfFields<    {
    signedHeader1: ContainerType<{
    message: ContainerType<{
    slot: UintBigintType;
    proposerIndex: UintNumberType;
    parentRoot: ByteVectorType;
    stateRoot: ByteVectorType;
    bodyRoot: ByteVectorType;
    }>;
    signature: ByteVectorType;
    }>;
    signedHeader2: ContainerType<{
    message: ContainerType<{
    slot: UintBigintType;
    proposerIndex: UintNumberType;
    parentRoot: ByteVectorType;
    stateRoot: ByteVectorType;
    bodyRoot: ByteVectorType;
    }>;
    signature: ByteVectorType;
    }>;
    }> | ValueOfFields<    {
    message: ContainerType<{
    epoch: UintNumberType;
    validatorIndex: UintNumberType;
    }>;
    signature: ByteVectorType;
    }> | ValueOfFields<    {
    blockRoot: StringType<string>;
    index: UintNumberType;
    slot: UintNumberType;
    kzgCommitment: StringType<string>;
    versionedHash: StringType<string>;
    }> | {
        slot: number;
        block: string;
        state: string;
        epochTransition: boolean;
        previousDutyDependentRoot: string;
        currentDutyDependentRoot: string;
        executionOptimistic: boolean;
    } | {
        slot: number;
        block: string;
        executionOptimistic: boolean;
    } | {
        slot: number;
        block: string;
    } | {
        block: string;
        state: string;
        epoch: number;
        executionOptimistic: boolean;
    } | {
        slot: number;
        depth: number;
        oldHeadBlock: string;
        newHeadBlock: string;
        oldHeadState: string;
        newHeadState: string;
        epoch: number;
        executionOptimistic: boolean;
    } | {
        version: ForkName;
        data: ValueOfFields<    {
        attestedHeader: ContainerType<{
        beacon: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
        }>;
        }>;
        syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
        }>;
        signatureSlot: UintNumberType;
        }> | ValueOfFields<    {
        attestedHeader: ContainerType<{
        beacon: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
        }>;
        execution: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactionsRoot: ByteVectorType;
        withdrawalsRoot: ByteVectorType;
        }>;
        executionBranch: VectorCompositeType<ByteVectorType>;
        }>;
        syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
        }>;
        signatureSlot: UintNumberType;
        }> | ValueOfFields<    {
        attestedHeader: ContainerType<{
        beacon: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
        }>;
        execution: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactionsRoot: ByteVectorType;
        withdrawalsRoot: ByteVectorType;
        blobGasUsed: UintBigintType;
        excessBlobGas: UintBigintType;
        }>;
        executionBranch: VectorCompositeType<ByteVectorType>;
        }>;
        syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
        }>;
        signatureSlot: UintNumberType;
        }> | ValueOfFields<    {
        attestedHeader: ContainerType<{
        beacon: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
        }>;
        execution: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactionsRoot: ByteVectorType;
        withdrawalsRoot: ByteVectorType;
        blobGasUsed: UintBigintType;
        excessBlobGas: UintBigintType;
        }>;
        executionBranch: VectorCompositeType<ByteVectorType>;
        }>;
        syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
        }>;
        signatureSlot: UintNumberType;
        }>;
    } | {
        version: ForkName;
        data: ValueOfFields<    {
        attestedHeader: ContainerType<{
        beacon: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
        }>;
        }>;
        finalizedHeader: ContainerType<{
        beacon: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
        }>;
        }>;
        finalityBranch: VectorCompositeType<ByteVectorType>;
        syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
        }>;
        signatureSlot: UintNumberType;
        }> | ValueOfFields<    {
        attestedHeader: ContainerType<{
        beacon: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
        }>;
        execution: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactionsRoot: ByteVectorType;
        withdrawalsRoot: ByteVectorType;
        }>;
        executionBranch: VectorCompositeType<ByteVectorType>;
        }>;
        finalizedHeader: ContainerType<{
        beacon: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
        }>;
        execution: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactionsRoot: ByteVectorType;
        withdrawalsRoot: ByteVectorType;
        }>;
        executionBranch: VectorCompositeType<ByteVectorType>;
        }>;
        finalityBranch: VectorCompositeType<ByteVectorType>;
        syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
        }>;
        signatureSlot: UintNumberType;
        }> | ValueOfFields<    {
        attestedHeader: ContainerType<{
        beacon: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
        }>;
        execution: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactionsRoot: ByteVectorType;
        withdrawalsRoot: ByteVectorType;
        blobGasUsed: UintBigintType;
        excessBlobGas: UintBigintType;
        }>;
        executionBranch: VectorCompositeType<ByteVectorType>;
        }>;
        finalizedHeader: ContainerType<{
        beacon: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
        }>;
        execution: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactionsRoot: ByteVectorType;
        withdrawalsRoot: ByteVectorType;
        blobGasUsed: UintBigintType;
        excessBlobGas: UintBigintType;
        }>;
        executionBranch: VectorCompositeType<ByteVectorType>;
        }>;
        finalityBranch: VectorCompositeType<ByteVectorType>;
        syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
        }>;
        signatureSlot: UintNumberType;
        }> | ValueOfFields<    {
        attestedHeader: ContainerType<{
        beacon: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
        }>;
        execution: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactionsRoot: ByteVectorType;
        withdrawalsRoot: ByteVectorType;
        blobGasUsed: UintBigintType;
        excessBlobGas: UintBigintType;
        }>;
        executionBranch: VectorCompositeType<ByteVectorType>;
        }>;
        finalizedHeader: ContainerType<{
        beacon: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
        }>;
        execution: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactionsRoot: ByteVectorType;
        withdrawalsRoot: ByteVectorType;
        blobGasUsed: UintBigintType;
        excessBlobGas: UintBigintType;
        }>;
        executionBranch: VectorCompositeType<ByteVectorType>;
        }>;
        finalityBranch: VectorCompositeType<ByteVectorType>;
        syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
        }>;
        signatureSlot: UintNumberType;
        }>;
    } | {
        version: ForkName;
        data: ValueOfFields<    {
        proposerIndex: UintNumberType;
        proposalSlot: UintNumberType;
        parentBlockNumber: UintNumberType;
        parentBlockRoot: ByteVectorType;
        parentBlockHash: ByteVectorType;
        payloadAttributes: ContainerType<{
        timestamp: UintNumberType;
        prevRandao: ByteVectorType;
        suggestedFeeRecipient: StringType<string>;
        }>;
        }> | ValueOfFields<    {
        proposerIndex: UintNumberType;
        proposalSlot: UintNumberType;
        parentBlockNumber: UintNumberType;
        parentBlockRoot: ByteVectorType;
        parentBlockHash: ByteVectorType;
        payloadAttributes: ContainerType<{
        timestamp: UintNumberType;
        prevRandao: ByteVectorType;
        suggestedFeeRecipient: StringType<string>;
        withdrawals: ListCompositeType<ContainerType<{
        index: UintNumberType;
        validatorIndex: UintNumberType;
        address: ExecutionAddressType;
        amount: UintBigintType;
        }>>;
        }>;
        }> | ValueOfFields<    {
        proposerIndex: UintNumberType;
        proposalSlot: UintNumberType;
        parentBlockNumber: UintNumberType;
        parentBlockRoot: ByteVectorType;
        parentBlockHash: ByteVectorType;
        payloadAttributes: ContainerType<{
        timestamp: UintNumberType;
        prevRandao: ByteVectorType;
        suggestedFeeRecipient: StringType<string>;
        withdrawals: ListCompositeType<ContainerType<{
        index: UintNumberType;
        validatorIndex: UintNumberType;
        address: ExecutionAddressType;
        amount: UintBigintType;
        }>>;
        parentBeaconBlockRoot: ByteVectorType;
        }>;
        }> | ValueOfFields<    {
        proposerIndex: UintNumberType;
        proposalSlot: UintNumberType;
        parentBlockNumber: UintNumberType;
        parentBlockRoot: ByteVectorType;
        parentBlockHash: ByteVectorType;
        payloadAttributes: ContainerType<{
        timestamp: UintNumberType;
        prevRandao: ByteVectorType;
        suggestedFeeRecipient: StringType<string>;
        withdrawals: ListCompositeType<ContainerType<{
        index: UintNumberType;
        validatorIndex: UintNumberType;
        address: ExecutionAddressType;
        amount: UintBigintType;
        }>>;
        parentBeaconBlockRoot: ByteVectorType;
        }>;
        }> | ValueOfFields<    {
        proposerIndex: UintNumberType;
        proposalSlot: UintNumberType;
        parentBlockNumber: UintNumberType;
        parentBlockRoot: ByteVectorType;
        parentBlockHash: ByteVectorType;
        payloadAttributes: ContainerType<{
        timestamp: UintNumberType;
        prevRandao: ByteVectorType;
        suggestedFeeRecipient: StringType<string>;
        withdrawals: ListCompositeType<ContainerType<{
        index: UintNumberType;
        validatorIndex: UintNumberType;
        address: ExecutionAddressType;
        amount: UintBigintType;
        }>>;
        parentBeaconBlockRoot: ByteVectorType;
        slotNumber: UintNumberType;
        }>;
        }>;
    } | {
        slot: number;
        builderIndex: number;
        blockHash: string;
        blockRoot: string;
        executionOptimistic: boolean;
    } | {
        slot: number;
        builderIndex: number;
        blockHash: string;
        blockRoot: string;
    } | {
        slot: number;
        blockRoot: string;
    } | {
        version: ForkName;
        data: ValueOfFields<    {
        message: ContainerType<{
        parentBlockHash: ByteVectorType;
        parentBlockRoot: ByteVectorType;
        blockHash: ByteVectorType;
        prevRandao: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        gasLimit: UintBigintType;
        builderIndex: UintNumberType;
        slot: UintNumberType;
        value: UintNumberType;
        executionPayment: UintNumberType;
        blobKzgCommitments: ListCompositeType<ByteVectorType>;
        executionRequestsRoot: ByteVectorType;
        }>;
        signature: ByteVectorType;
        }>;
    } | DataColumnSidecarSSE;
};

declare function getFinalizedSyncCheckpoint(api: Pick<ApiClient, "beacon">): Promise<Bytes32_2>;

/**
 * Return the ForkVersion at an epoch from a Fork type
 */
declare function getForkVersion(fork: ts.Fork, epoch: Epoch): Version_2;

declare function getGenesisData(api: Pick<ApiClient, "beacon">): Promise<GenesisData>;

/**
 * @deprecated - Use `getConsoleLogger` instead.
 */
declare const getLcLoggerConsole: typeof getConsoleLogger;

/**
 * Util to guarantee that all bits have a corresponding pubkey
 */
declare function getParticipantPubkeys<T>(pubkeys: T[], bits: BitArray): T[];

declare function getTypeByEvent(config: ChainForkConfig): {
    [K in EventType]: TypeJson<EventData[K]>;
};

declare type Gindex = bigint;

declare type GindexBitstring = string;

declare type GloasDataColumnSidecarSSE = ValueOf<typeof gloasDataColumnSidecarSSE>;

declare const gloasDataColumnSidecarSSE: ContainerType<{
    blockRoot: StringType<string>;
    index: UintNumberType;
    slot: UintNumberType;
}>;

declare const Goodbye: UintBigintType;

declare type Goodbye_2 = ValueOf<typeof ssz_2.Goodbye>;

declare type GossipPeerScoreStat = {
    peerId: string;
};

declare type GossipQueueItem = {
    topic: unknown;
    propagationSource: string;
    data: Uint8Array;
    addedTimeMs: number;
    seenTimestampSec: number;
};

declare const Gwei: UintBigintType;

/**
 * HashComputation to be later used to compute hash of nodes from bottom up.
 * This is also an item of a linked list.
 *     ╔═════════════════════╗             ╔══════════════════════╗
 *     ║       dest          ║             ║      next_dest       ║
 *     ║     /      \        ║  ========>  ║     /       \        ║
 *     ║  src0      src1     ║             ║  next_src0  next_src1║
 *     ╚═════════════════════╝             ╚══════════════════════╝
 */
declare type HashComputation = {
    src0: Node_2;
    src1: Node_2;
    dest: Node_2;
    next: HashComputation | null;
};

/**
 * Model HashComputationLevel[] at different levels.
 */
declare class HashComputationGroup {
    readonly byLevel: HashComputationLevel[];
    constructor();
    reset(): void;
    clean(): void;
}

/**
 * Model HashComputation[] at the same level that support reusing the same memory.
 * Before every run, reset() should be called.
 * After every run, clean() should be called.
 */
declare class HashComputationLevel implements IterableIterator<HashComputation> {
    private _length;
    private _totalLength;
    private head;
    private tail;
    private pointer;
    constructor();
    get length(): number;
    get totalLength(): number;
    /**
     * run before every run
     */
    reset(): void;
    /**
     * Append a new HashComputation to tail.
     * This will overwrite the existing HashComputation if it is not null, or grow the list if needed.
     */
    push(src0: Node_2, src1: Node_2, dest: Node_2): void;
    /**
     * run after every run
     * hashComps may still refer to the old Nodes, we should release them to avoid memory leak.
     */
    clean(): void;
    /**
     * Implement Iterator for this class
     */
    next(): IteratorResult<HashComputation>;
    /**
     * This is convenient method to consume HashComputationLevel with for-of loop
     * See "next" method above for the actual implementation
     */
    [Symbol.iterator](): IterableIterator<HashComputation>;
    /**
     * Not great due to memory allocation, for testing only.
     * This converts all HashComputation with data to an array.
     */
    toArray(): HashComputation[];
    /**
     * For testing only.
     * This dumps all backed HashComputation objects, note that some HashComputation may not have data.
     */
    dump(): HashComputation[];
}

declare type HashList = ValueOf<typeof HashListType>;

declare const HashListType: ListCompositeType<ByteVectorType>;

declare type HasOnlyOptionalProps<T> = {
    [K in keyof T]-?: object extends Pick<T, K> ? never : K;
} extends {
    [K2 in keyof T]: never;
} ? true : false;

declare type HeaderParams = Record<string, string>;

/**
 * Extension of Headers object returned by Fetch API
 */
declare class HeadersExtra extends Headers {
    /**
     * Get required header from response headers
     */
    getRequired(name: string): string;
    /**
     * Get optional header from response headers.
     * Return default value if it does not exist
     */
    getOrDefault(name: string, defaultValue: string): string;
}

declare const HistoricalBatch: ContainerType<{
    blockRoots: VectorCompositeType<ByteVectorType>;
    stateRoots: VectorCompositeType<ByteVectorType>;
}>;

declare type HistoricalBatch_2 = ValueOf<typeof ssz_2.HistoricalBatch>;

/**
 * Non-spec'ed helper type to allow efficient hashing in epoch transition.
 * This type is like a 'Header' of HistoricalBatch where its fields are hashed.
 */
declare const HistoricalBatchRoots: ContainerType<{
    blockRoots: ByteVectorType;
    stateRoots: ByteVectorType;
}>;

declare const HistoricalBlockRoots: VectorCompositeType<ByteVectorType>;

declare const HistoricalStateRoots: VectorCompositeType<ByteVectorType>;

declare const HistoricalSummaries: ListCompositeType<ContainerType<{
    blockSummaryRoot: ByteVectorType;
    stateSummaryRoot: ByteVectorType;
}>>;

declare type HistoricalSummaries_2 = ValueOf<typeof ssz_5.HistoricalSummaries>;

declare type HistoricalSummariesResponse = ValueOf<typeof HistoricalSummariesResponseType>;

declare const HistoricalSummariesResponseType: ContainerType<{
    slot: UintNumberType;
    historicalSummaries: ListCompositeType<ContainerType<{
    blockSummaryRoot: ByteVectorType;
    stateSummaryRoot: ByteVectorType;
    }>>;
    proof: ArrayType<Type<Uint8Array<ArrayBufferLike>>, unknown, unknown>;
}>;

declare const HistoricalSummary: ContainerType<{
    blockSummaryRoot: ByteVectorType;
    stateSummaryRoot: ByteVectorType;
}>;

declare type Hook = (newRootNode: Node_2) => void;

declare type HttpMethod = "GET" | "POST" | "DELETE";

/**
 * Rewards info for ideal attestations ie. Maximum rewards could be earned by making timely head, target and source vote.
 * `effectiveBalance` is in Gwei
 */
declare type IdealAttestationsReward = ValueOf<typeof IdealAttestationsRewardsType>;

declare const IdealAttestationsRewardsType: ContainerType<{
    /** Reward for head vote. Could be negative to indicate penalty */
    head: UintNumberType;
    /** Reward for target vote. Could be negative to indicate penalty */
    target: UintNumberType;
    /** Reward for source vote. Could be negative to indicate penalty */
    source: UintNumberType;
    /** Inclusion delay reward (phase0 only) */
    inclusionDelay: UintNumberType;
    /** Inactivity penalty. Should be a negative number to indicate penalty */
    inactivity: UintNumberType;
    effectiveBalance: UintNumberType;
}>;

declare interface IHttpClient {
    readonly baseUrl: string;
    readonly urlsInits: UrlInitRequired[];
    readonly urlsScore: number[];
    request<E extends Endpoint>(definition: RouteDefinitionExtra<E>, args: E["args"], localInit?: ApiRequestInit): Promise<ApiResponse<E>>;
}

declare type ILcLogger = {
    error: LogHandler;
    warn: LogHandler;
    info: LogHandler;
    debug: LogHandler;
};

declare const InactivityScores: ListBasicType<UintNumberType>;

declare const IndexedAttestation: ContainerType<{
    attestingIndices: ListBasicType<UintNumberType>;
    data: ContainerType<{
        slot: UintNumberType;
        index: UintNumberType;
        beaconBlockRoot: ByteVectorType;
        source: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
        }>;
        target: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
        }>;
    }>;
    signature: ByteVectorType;
}>;

declare type IndexedAttestation_2 = ValueOf<typeof ssz_2.IndexedAttestation>;

declare const IndexedAttestation_3: ContainerType<{
    attestingIndices: ListBasicType<UintNumberType>;
    data: ContainerType<{
        slot: UintNumberType;
        index: UintNumberType;
        beaconBlockRoot: ByteVectorType;
        source: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
        }>;
        target: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
        }>;
    }>;
    signature: ByteVectorType;
}>;

declare type IndexedAttestation_4 = ValueOf<typeof ssz_7.IndexedAttestation>;

/** Same as `IndexedAttestation` but epoch, slot and index are not bounded and must be a bigint */
declare const IndexedAttestationBigint: ContainerType<{
    attestingIndices: ListBasicType<UintNumberType>;
    data: ContainerType<{
        slot: UintBigintType;
        index: UintBigintType;
        beaconBlockRoot: ByteVectorType;
        source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
        }>;
        target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
        }>;
    }>;
    signature: ByteVectorType;
}>;

declare type IndexedAttestationBigint_2 = ValueOf<typeof ssz_2.IndexedAttestationBigint>;

/** Same as `IndexedAttestation` but epoch, slot and index are not bounded and must be a bigint */
declare const IndexedAttestationBigint_3: ContainerType<{
    attestingIndices: ListBasicType<UintNumberType>;
    data: ContainerType<{
        slot: UintBigintType;
        index: UintBigintType;
        beaconBlockRoot: ByteVectorType;
        source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
        }>;
        target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
        }>;
    }>;
    signature: ByteVectorType;
}>;

declare type IndexedAttestationBigint_4 = ValueOf<typeof ssz_7.IndexedAttestationBigint>;

declare const IndexedPayloadAttestation: ContainerType<{
    attestingIndices: ListBasicType<UintNumberType>;
    data: ContainerType<{
        beaconBlockRoot: ByteVectorType;
        slot: UintNumberType;
        payloadPresent: BooleanType;
        blobDataAvailable: BooleanType;
    }>;
    signature: ByteVectorType;
}>;

declare type IndexedPayloadAttestation_2 = ValueOf<typeof ssz_9.IndexedPayloadAttestation>;

/**
 * Returns the update with more bits. On ties, newUpdate is the better
 *
 * Spec v1.0.1
 * ```python
 * max(store.valid_updates, key=lambda update: sum(update.sync_committee_bits)))
 * ```
 */
declare function isBetterUpdate(prev: LightclientUpdateStats, next: LightclientUpdateStats): boolean;

declare function isEmptyHeader(header: BeaconBlockHeader_2): boolean;

declare const isNode: boolean;

/**
 * Verify that the given ``leaf`` is on the merkle branch ``proof``
 * starting with the given ``root``.
 *
 * Browser friendly version of verifyMerkleBranch
 */
declare function isValidMerkleBranch(leaf: Uint8Array, proof: Uint8Array[], depth: number, index: number, root: Uint8Array): boolean;

declare function isZeroHash(root: Root_2): boolean;

/**
 * JSON Proof path
 * @example
 * ```
 * ["validators", 1234, "slashed"]
 * ```
 */
declare type JsonPath = JsonPathProp[];

/**
 * JSON path property
 * @example Container property
 * ```
 * "validators"
 * ```
 * @example Array index
 * ```
 * 1234
 * ```
 */
declare type JsonPathProp = string | number;

declare type JsonRequestData<B = unknown, P extends PathParams = PathParams, Q extends QueryParams = QueryParams, H extends HeaderParams = HeaderParams> = RequestData<P, Q, H> & {
    body?: B;
};

declare type JsonRequestMethods<E extends Endpoint> = {
    writeReqJson: (p: E["args"]) => E["request"];
    parseReqJson: (r: E["request"]) => E["args"];
};

declare const JustificationBits: BitVectorType;

declare type KeyCase = "eth2" | "snake" | "constant" | "camel" | "header" | "pascal";

declare const KZGCommitment: ByteVectorType;

declare type KZGCommitment_2 = ValueOf<typeof ssz_6.KZGCommitment>;

declare const KzgCommitmentInclusionProof: VectorCompositeType<ByteVectorType>;

declare type KzgCommitmentInclusionProof_2 = ValueOf<typeof ssz_6.KzgCommitmentInclusionProof>;

declare const KzgCommitmentsInclusionProof: VectorCompositeType<ByteVectorType>;

declare type KzgCommitmentsInclusionProof_2 = ValueOf<typeof ssz_8.KzgCommitmentsInclusionProof>;

declare type KZGProof = ValueOf<typeof ssz_6.KZGProof>;

declare const KZGProof_2: ByteVectorType;

declare type KZGProof_3 = ValueOf<typeof ssz_8.KZGProof>;

declare const KZGProof_4: ByteVectorType;

declare const KZGProofs: ListCompositeType<ByteVectorType>;

declare type KZGProofs_2 = ValueOf<typeof ssz_6.KZGProofs>;

declare const KZGProofs_3: ListCompositeType<ByteVectorType>;

/**
 * An immutable binary merkle tree node that has no children
 */
declare class LeafNode extends Node_2 {
    get rootHashObject(): HashObject;
    get root(): Uint8Array;
    get left(): Node_2;
    get right(): Node_2;
    static fromRoot(root: Uint8Array): LeafNode;
    /**
     * New LeafNode from existing HashObject.
     */
    static fromHashObject(ho: HashObject): LeafNode;
    /**
     * New LeafNode with its internal value set to zero. Consider using `zeroNode(0)` if you don't need to mutate.
     */
    static fromZero(): LeafNode;
    /**
     * LeafNode with HashObject `(uint32, 0, 0, 0, 0, 0, 0, 0)`.
     */
    static fromUint32(uint32: number): LeafNode;
    /**
     * Create a new LeafNode with the same internal values. The returned instance is safe to mutate
     */
    clone(): LeafNode;
    isLeaf(): boolean;
    writeToBytes(data: Uint8Array, start: number, size: number): void;
    getUint(uintBytes: number, offsetBytes: number, clipInfinity?: boolean): number;
    getUintBigint(uintBytes: number, offsetBytes: number): bigint;
    setUint(uintBytes: number, offsetBytes: number, value: number, clipInfinity?: boolean): void;
    setUintBigint(uintBytes: number, offsetBytes: number, valueBN: bigint): void;
    bitwiseOrUint(uintBytes: number, offsetBytes: number, value: number): void;
}

/**
 * Server-based Lightclient. Current architecture diverges from the spec's proposed updated splitting them into:
 * - Sync period updates: To advance to the next sync committee
 * - Header updates: To get a more recent header signed by a known sync committee
 *
 * To stay synced to the current sync period it needs:
 * - GET lightclient/committee_updates at least once per period.
 *
 * To get continuous header updates:
 * - subscribe to SSE type lightclient_update
 *
 * To initialize, it needs:
 * - GenesisData: To initialize the clock and verify signatures
 *   - For known networks it's hardcoded in the source
 *   - For unknown networks it can be provided by the user with a manual input
 *   - For unknown test networks it can be queried from a trusted node at GET beacon/genesis
 * - `beaconApiUrl`: To connect to a trustless beacon node
 * - `LightclientStore`: To have an initial trusted SyncCommittee to start the sync
 *   - For new lightclient instances, it can be queries from a trustless node at GET lightclient/bootstrap
 *   - For existing lightclient instances, it should be retrieved from storage
 *
 * When to trigger a committee update sync:
 *
 *  period 0         period 1         period 2
 * -|----------------|----------------|----------------|-> time
 *              | now
 *               - active current_sync_committee
 *               - known next_sync_committee, signed by current_sync_committee
 *
 * - No need to query for period 0 next_sync_committee until the end of period 0
 * - During most of period 0, current_sync_committee known, next_sync_committee unknown
 * - At the end of period 0, get a sync committee update, and populate period 1's committee
 *
 * syncCommittees: Map<SyncPeriod, SyncCommittee>, limited to max of 2 items
 */
export declare class Lightclient {
    readonly emitter: LightclientEmitter;
    readonly config: BeaconConfig;
    readonly logger: ILcLogger;
    readonly genesisValidatorsRoot: Uint8Array;
    readonly genesisTime: number;
    private readonly transport;
    private readonly lightclientSpec;
    private runStatus;
    constructor({ config, logger, genesisData, bootstrap, transport }: LightclientInitArgs);
    get status(): RunStatusCode;
    get currentSlot(): number;
    static initializeFromCheckpointRoot(args: Omit<LightclientInitArgs, "bootstrap"> & {
        checkpointRoot: ts.Checkpoint["root"];
    }): Promise<Lightclient>;
    /**
     * @returns a `Promise` that will resolve once `runStatus` equals `RunStatusCode.started`
     */
    start(): Promise<void>;
    stop(): void;
    getHead(): LightClientHeader_7;
    getFinalized(): LightClientHeader_7;
    sync(fromPeriod: SyncPeriod_2, toPeriod: SyncPeriod_2): Promise<void>;
    private runLoop;
    /**
     * Processes new optimistic header updates in only known synced sync periods.
     * This headerUpdate may update the head if there's enough participation.
     */
    private processOptimisticUpdate;
    /**
     * Processes new header updates in only known synced sync periods.
     * This headerUpdate may update the head if there's enough participation.
     */
    private processFinalizedUpdate;
    private processSyncCommitteeUpdate;
    private currentSlotWithTolerance;
    private updateRunStatus;
}

declare namespace lightclient {
    export {
        getDefinitions_9 as getDefinitions,
        HashListType,
        HashList,
        Endpoints_10 as Endpoints
    }
}

declare const LightClientBootstrap: ContainerType<{
    header: ContainerType<{
        beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
    }>;
    currentSyncCommittee: ContainerType<{
        pubkeys: VectorCompositeType<ByteVectorType>;
        aggregatePubkey: ByteVectorType;
    }>;
    currentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
}>;

declare type LightClientBootstrap_2 = ValueOf<typeof ssz_3.LightClientBootstrap>;

declare const LightClientBootstrap_3: ContainerType<{
    header: ContainerType<{
        beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        execution: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
        }>;
        executionBranch: VectorCompositeType<ByteVectorType>;
    }>;
    currentSyncCommittee: ContainerType<{
        pubkeys: VectorCompositeType<ByteVectorType>;
        aggregatePubkey: ByteVectorType;
    }>;
    currentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
}>;

declare type LightClientBootstrap_4 = ValueOf<typeof ssz_5.LightClientBootstrap>;

declare const LightClientBootstrap_5: ContainerType<{
    header: ContainerType<{
        beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        execution: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
        }>;
        executionBranch: VectorCompositeType<ByteVectorType>;
    }>;
    currentSyncCommittee: ContainerType<{
        pubkeys: VectorCompositeType<ByteVectorType>;
        aggregatePubkey: ByteVectorType;
    }>;
    currentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
}>;

declare type LightClientBootstrap_6 = ValueOf<typeof ssz_6.LightClientBootstrap>;

declare const LightClientBootstrap_7: ContainerType<{
    header: ContainerType<{
        beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        execution: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
        }>;
        executionBranch: VectorCompositeType<ByteVectorType>;
    }>;
    currentSyncCommittee: ContainerType<{
        pubkeys: VectorCompositeType<ByteVectorType>;
        aggregatePubkey: ByteVectorType;
    }>;
    currentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
}>;

declare type LightClientBootstrap_8 = ValueOf<typeof ssz_7.LightClientBootstrap>;

declare type LightClientBootstrap_9<F extends ForkPostAltair = ForkPostAltair> = TypesByFork[F]["LightClientBootstrap"];

declare type LightclientEmitter = Emitter<LightclientEmitterEvents>;

declare type LightclientEmitterEvents = {
    [LightclientEvent.lightClientOptimisticHeader]: (newHeader: LightClientHeader_7) => void;
    [LightclientEvent.lightClientFinalityHeader]: (newHeader: LightClientHeader_7) => void;
    [LightclientEvent.statusChange]: (code: RunStatusCode) => void;
};

export declare enum LightclientEvent {
    lightClientOptimisticHeader = "light_client_optimistic_header",
    lightClientFinalityHeader = "light_client_finality_header",
    statusChange = "light_client_status_change"
}

declare type LightClientFinalityUpdate<F extends ForkPostAltair = ForkPostAltair> = TypesByFork[F]["LightClientFinalityUpdate"];

declare const LightClientFinalityUpdate_2: ContainerType<{
    attestedHeader: ContainerType<{
        beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
    }>;
    finalizedHeader: ContainerType<{
        beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
    }>;
    finalityBranch: VectorCompositeType<ByteVectorType>;
    syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
    }>;
    signatureSlot: UintNumberType;
}>;

declare type LightClientFinalityUpdate_3 = ValueOf<typeof ssz_3.LightClientFinalityUpdate>;

declare const LightClientFinalityUpdate_4: ContainerType<{
    attestedHeader: ContainerType<{
        beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        execution: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
        }>;
        executionBranch: VectorCompositeType<ByteVectorType>;
    }>;
    finalizedHeader: ContainerType<{
        beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        execution: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
        }>;
        executionBranch: VectorCompositeType<ByteVectorType>;
    }>;
    finalityBranch: VectorCompositeType<ByteVectorType>;
    syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
    }>;
    signatureSlot: UintNumberType;
}>;

declare type LightClientFinalityUpdate_5 = ValueOf<typeof ssz_5.LightClientFinalityUpdate>;

declare const LightClientFinalityUpdate_6: ContainerType<{
    attestedHeader: ContainerType<{
        beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        execution: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
        }>;
        executionBranch: VectorCompositeType<ByteVectorType>;
    }>;
    finalizedHeader: ContainerType<{
        beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        execution: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
        }>;
        executionBranch: VectorCompositeType<ByteVectorType>;
    }>;
    finalityBranch: VectorCompositeType<ByteVectorType>;
    syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
    }>;
    signatureSlot: UintNumberType;
}>;

declare type LightClientFinalityUpdate_7 = ValueOf<typeof ssz_6.LightClientFinalityUpdate>;

declare const LightClientFinalityUpdate_8: ContainerType<{
    attestedHeader: ContainerType<{
        beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        execution: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
        }>;
        executionBranch: VectorCompositeType<ByteVectorType>;
    }>;
    finalizedHeader: ContainerType<{
        beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        execution: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
        }>;
        executionBranch: VectorCompositeType<ByteVectorType>;
    }>;
    finalityBranch: VectorCompositeType<ByteVectorType>;
    syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
    }>;
    signatureSlot: UintNumberType;
}>;

declare type LightClientFinalityUpdate_9 = ValueOf<typeof ssz_7.LightClientFinalityUpdate>;

declare const LightClientHeader: ContainerType<{
    beacon: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
    }>;
}>;

declare type LightClientHeader_2 = ValueOf<typeof ssz_3.LightClientHeader>;

declare const LightClientHeader_3: ContainerType<{
    beacon: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
    }>;
    execution: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactionsRoot: ByteVectorType;
        withdrawalsRoot: ByteVectorType;
    }>;
    executionBranch: VectorCompositeType<ByteVectorType>;
}>;

declare type LightClientHeader_4 = ValueOf<typeof ssz_5.LightClientHeader>;

declare const LightClientHeader_5: ContainerType<{
    beacon: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
    }>;
    execution: ContainerType<{
        parentHash: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        stateRoot: ByteVectorType;
        receiptsRoot: ByteVectorType;
        logsBloom: ByteVectorType;
        prevRandao: ByteVectorType;
        blockNumber: UintNumberType;
        gasLimit: UintNumberType;
        gasUsed: UintNumberType;
        timestamp: UintNumberType;
        extraData: ByteListType;
        baseFeePerGas: UintBigintType;
        blockHash: ByteVectorType;
        transactionsRoot: ByteVectorType;
        withdrawalsRoot: ByteVectorType;
        blobGasUsed: UintBigintType;
        excessBlobGas: UintBigintType;
    }>;
    executionBranch: VectorCompositeType<ByteVectorType>;
}>;

declare type LightClientHeader_6 = ValueOf<typeof ssz_6.LightClientHeader>;

declare type LightClientHeader_7<F extends ForkPostAltair = ForkPostAltair> = TypesByFork[F]["LightClientHeader"];

export declare type LightclientInitArgs = {
    config: ChainForkConfig;
    logger?: ILcLogger;
    opts?: LightclientOpts;
    genesisData: GenesisData;
    transport: LightClientTransport;
    bootstrap: LightClientBootstrap_9;
};

declare const LightClientOptimisticUpdate: ContainerType<{
    attestedHeader: ContainerType<{
        beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
    }>;
    syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
    }>;
    signatureSlot: UintNumberType;
}>;

declare type LightClientOptimisticUpdate_2 = ValueOf<typeof ssz_3.LightClientOptimisticUpdate>;

declare const LightClientOptimisticUpdate_3: ContainerType<{
    attestedHeader: ContainerType<{
        beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        execution: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
        }>;
        executionBranch: VectorCompositeType<ByteVectorType>;
    }>;
    syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
    }>;
    signatureSlot: UintNumberType;
}>;

declare type LightClientOptimisticUpdate_4 = ValueOf<typeof ssz_5.LightClientOptimisticUpdate>;

declare const LightClientOptimisticUpdate_5: ContainerType<{
    attestedHeader: ContainerType<{
        beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        execution: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
        }>;
        executionBranch: VectorCompositeType<ByteVectorType>;
    }>;
    syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
    }>;
    signatureSlot: UintNumberType;
}>;

declare type LightClientOptimisticUpdate_6 = ValueOf<typeof ssz_6.LightClientOptimisticUpdate>;

declare const LightClientOptimisticUpdate_7: ContainerType<{
    attestedHeader: ContainerType<{
        beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        execution: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
        }>;
        executionBranch: VectorCompositeType<ByteVectorType>;
    }>;
    syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
    }>;
    signatureSlot: UintNumberType;
}>;

declare type LightClientOptimisticUpdate_8 = ValueOf<typeof ssz_7.LightClientOptimisticUpdate>;

declare type LightClientOptimisticUpdate_9<F extends ForkPostAltair = ForkPostAltair> = TypesByFork[F]["LightClientOptimisticUpdate"];

export declare type LightclientOpts = ProcessUpdateOpts;

declare type LightClientRestEmitter = Emitter<LightClientRestEvents>;

declare type LightClientRestEvents = {
    [routes.events.EventType.lightClientFinalityUpdate]: (update: LightClientFinalityUpdate) => void;
    [routes.events.EventType.lightClientOptimisticUpdate]: (update: LightClientOptimisticUpdate_9) => void;
};

declare class LightClientRestTransport implements LightClientTransport {
    private readonly api;
    private controller;
    private readonly eventEmitter;
    private subscribedEventstream;
    constructor(api: ApiClient);
    getUpdates(startPeriod: SyncPeriod_2, count: number): Promise<{
        version: ForkName;
        data: LightClientUpdate_9;
    }[]>;
    getOptimisticUpdate(): Promise<{
        version: ForkName;
        data: LightClientOptimisticUpdate_9;
    }>;
    getFinalityUpdate(): Promise<{
        version: ForkName;
        data: LightClientFinalityUpdate;
    }>;
    getBootstrap(blockRoot: string): Promise<{
        version: ForkName;
        data: LightClientBootstrap_9;
    }>;
    onOptimisticUpdate(handler: (optimisticUpdate: LightClientOptimisticUpdate_9) => void): void;
    onFinalityUpdate(handler: (finalityUpdate: LightClientFinalityUpdate) => void): void;
    private subscribeEventstream;
}

declare const LightClientStore: ContainerType<{
    snapshot: ContainerType<{
        header: ContainerType<{
            beacon: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
        }>;
        currentSyncCommittee: ContainerType<{
            pubkeys: VectorCompositeType<ByteVectorType>;
            aggregatePubkey: ByteVectorType;
        }>;
        currentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
    }>;
    validUpdates: ListCompositeType<ContainerType<{
        attestedHeader: ContainerType<{
            beacon: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
        }>;
        nextSyncCommittee: ContainerType<{
            pubkeys: VectorCompositeType<ByteVectorType>;
            aggregatePubkey: ByteVectorType;
        }>;
        nextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
        finalizedHeader: ContainerType<{
            beacon: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
        }>;
        finalityBranch: VectorCompositeType<ByteVectorType>;
        syncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
        }>;
        signatureSlot: UintNumberType;
    }>>;
}>;

declare type LightClientStore_2 = ValueOf<typeof ssz_3.LightClientStore>;

declare const LightClientStore_3: ContainerType<{
    snapshot: ContainerType<{
        header: ContainerType<{
            beacon: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            execution: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
            }>;
            executionBranch: VectorCompositeType<ByteVectorType>;
        }>;
        currentSyncCommittee: ContainerType<{
            pubkeys: VectorCompositeType<ByteVectorType>;
            aggregatePubkey: ByteVectorType;
        }>;
        currentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
    }>;
    validUpdates: ListCompositeType<ContainerType<{
        attestedHeader: ContainerType<{
            beacon: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            execution: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
            }>;
            executionBranch: VectorCompositeType<ByteVectorType>;
        }>;
        nextSyncCommittee: ContainerType<{
            pubkeys: VectorCompositeType<ByteVectorType>;
            aggregatePubkey: ByteVectorType;
        }>;
        nextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
        finalizedHeader: ContainerType<{
            beacon: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            execution: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
            }>;
            executionBranch: VectorCompositeType<ByteVectorType>;
        }>;
        finalityBranch: VectorCompositeType<ByteVectorType>;
        syncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
        }>;
        signatureSlot: UintNumberType;
    }>>;
}>;

declare type LightClientStore_4 = ValueOf<typeof ssz_5.LightClientStore>;

declare const LightClientStore_5: ContainerType<{
    snapshot: ContainerType<{
        header: ContainerType<{
            beacon: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            execution: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            executionBranch: VectorCompositeType<ByteVectorType>;
        }>;
        currentSyncCommittee: ContainerType<{
            pubkeys: VectorCompositeType<ByteVectorType>;
            aggregatePubkey: ByteVectorType;
        }>;
        currentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
    }>;
    validUpdates: ListCompositeType<ContainerType<{
        attestedHeader: ContainerType<{
            beacon: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            execution: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            executionBranch: VectorCompositeType<ByteVectorType>;
        }>;
        nextSyncCommittee: ContainerType<{
            pubkeys: VectorCompositeType<ByteVectorType>;
            aggregatePubkey: ByteVectorType;
        }>;
        nextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
        finalizedHeader: ContainerType<{
            beacon: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            execution: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            executionBranch: VectorCompositeType<ByteVectorType>;
        }>;
        finalityBranch: VectorCompositeType<ByteVectorType>;
        syncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
        }>;
        signatureSlot: UintNumberType;
    }>>;
}>;

declare type LightClientStore_6 = ValueOf<typeof ssz_6.LightClientStore>;

declare const LightClientStore_7: ContainerType<{
    snapshot: ContainerType<{
        header: ContainerType<{
            beacon: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            execution: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            executionBranch: VectorCompositeType<ByteVectorType>;
        }>;
        currentSyncCommittee: ContainerType<{
            pubkeys: VectorCompositeType<ByteVectorType>;
            aggregatePubkey: ByteVectorType;
        }>;
        currentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
    }>;
    validUpdates: ListCompositeType<ContainerType<{
        attestedHeader: ContainerType<{
            beacon: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            execution: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            executionBranch: VectorCompositeType<ByteVectorType>;
        }>;
        nextSyncCommittee: ContainerType<{
            pubkeys: VectorCompositeType<ByteVectorType>;
            aggregatePubkey: ByteVectorType;
        }>;
        nextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
        finalizedHeader: ContainerType<{
            beacon: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            execution: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            executionBranch: VectorCompositeType<ByteVectorType>;
        }>;
        finalityBranch: VectorCompositeType<ByteVectorType>;
        syncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
        }>;
        signatureSlot: UintNumberType;
    }>>;
}>;

declare type LightClientStore_8 = ValueOf<typeof ssz_7.LightClientStore>;

declare interface LightClientTransport {
    getUpdates(startPeriod: SyncPeriod_2, count: number): Promise<{
        version: ForkName;
        data: LightClientUpdate_9;
    }[]>;
    /**
     * Returns the latest optimistic head update available. Clients should use the SSE type `light_client_optimistic_update`
     * unless to get the very first head update after syncing, or if SSE are not supported by the server.
     */
    getOptimisticUpdate(): Promise<{
        version: ForkName;
        data: LightClientOptimisticUpdate_9;
    }>;
    getFinalityUpdate(): Promise<{
        version: ForkName;
        data: LightClientFinalityUpdate;
    }>;
    /**
     * Fetch a bootstrapping state with a proof to a trusted block root.
     * The trusted block root should be fetched with similar means to a weak subjectivity checkpoint.
     * Only block roots for checkpoints are guaranteed to be available.
     */
    getBootstrap(blockRoot: string): Promise<{
        version: ForkName;
        data: LightClientBootstrap_9;
    }>;
    onOptimisticUpdate(handler: (optimisticUpdate: LightClientOptimisticUpdate_9) => void): void;
    onFinalityUpdate(handler: (finalityUpdate: LightClientFinalityUpdate) => void): void;
}

declare const LightClientUpdate: ContainerType<{
    attestedHeader: ContainerType<{
        beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
    }>;
    nextSyncCommittee: ContainerType<{
        pubkeys: VectorCompositeType<ByteVectorType>;
        aggregatePubkey: ByteVectorType;
    }>;
    nextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
    finalizedHeader: ContainerType<{
        beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
    }>;
    finalityBranch: VectorCompositeType<ByteVectorType>;
    syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
    }>;
    signatureSlot: UintNumberType;
}>;

declare type LightClientUpdate_2 = ValueOf<typeof ssz_3.LightClientUpdate>;

declare const LightClientUpdate_3: ContainerType<{
    attestedHeader: ContainerType<{
        beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        execution: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
        }>;
        executionBranch: VectorCompositeType<ByteVectorType>;
    }>;
    nextSyncCommittee: ContainerType<{
        pubkeys: VectorCompositeType<ByteVectorType>;
        aggregatePubkey: ByteVectorType;
    }>;
    nextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
    finalizedHeader: ContainerType<{
        beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        execution: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
        }>;
        executionBranch: VectorCompositeType<ByteVectorType>;
    }>;
    finalityBranch: VectorCompositeType<ByteVectorType>;
    syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
    }>;
    signatureSlot: UintNumberType;
}>;

declare type LightClientUpdate_4 = ValueOf<typeof ssz_5.LightClientUpdate>;

declare const LightClientUpdate_5: ContainerType<{
    attestedHeader: ContainerType<{
        beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        execution: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
        }>;
        executionBranch: VectorCompositeType<ByteVectorType>;
    }>;
    nextSyncCommittee: ContainerType<{
        pubkeys: VectorCompositeType<ByteVectorType>;
        aggregatePubkey: ByteVectorType;
    }>;
    nextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
    finalizedHeader: ContainerType<{
        beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        execution: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
        }>;
        executionBranch: VectorCompositeType<ByteVectorType>;
    }>;
    finalityBranch: VectorCompositeType<ByteVectorType>;
    syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
    }>;
    signatureSlot: UintNumberType;
}>;

declare type LightClientUpdate_6 = ValueOf<typeof ssz_6.LightClientUpdate>;

declare const LightClientUpdate_7: ContainerType<{
    attestedHeader: ContainerType<{
        beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        execution: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
        }>;
        executionBranch: VectorCompositeType<ByteVectorType>;
    }>;
    nextSyncCommittee: ContainerType<{
        pubkeys: VectorCompositeType<ByteVectorType>;
        aggregatePubkey: ByteVectorType;
    }>;
    nextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
    finalizedHeader: ContainerType<{
        beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        execution: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
        }>;
        executionBranch: VectorCompositeType<ByteVectorType>;
    }>;
    finalityBranch: VectorCompositeType<ByteVectorType>;
    syncAggregate: ContainerType<{
        syncCommitteeBits: BitVectorType;
        syncCommitteeSignature: ByteVectorType;
    }>;
    signatureSlot: UintNumberType;
}>;

declare type LightClientUpdate_8 = ValueOf<typeof ssz_7.LightClientUpdate>;

declare type LightClientUpdate_9<F extends ForkPostAltair = ForkPostAltair> = TypesByFork[F]["LightClientUpdate"];

declare const LightClientUpdatesByRange: ContainerType<{
    startPeriod: UintNumberType;
    count: UintNumberType;
}>;

declare type LightClientUpdatesByRange_2 = ValueOf<typeof ssz_3.LightClientUpdatesByRange>;

declare type LightclientUpdateStats = {
    isFinalized: boolean;
    participation: number;
    slot: Slot_2;
};

declare interface ListBasicOpts {
    typeName?: string;
    cachePermanentRootStruct?: boolean;
}

declare class ListBasicTreeView<ElementType extends BasicType<unknown>> extends ArrayBasicTreeView<ElementType> {
    readonly type: ListBasicType_2<ElementType>;
    protected tree: Tree;
    constructor(type: ListBasicType_2<ElementType>, tree: Tree);
    /**
     * Adds one value element at the end of the array and adds 1 to the current Tree length.
     */
    push(value: ValueOf<ElementType>): void;
}

declare class ListBasicTreeViewDU<ElementType extends BasicType<unknown>> extends ArrayBasicTreeViewDU<ElementType> {
    readonly type: ListBasicType_2<ElementType>;
    protected _rootNode: Node_2;
    constructor(type: ListBasicType_2<ElementType>, _rootNode: Node_2, cache?: ArrayBasicTreeViewDUCache);
    /**
     * Adds one value element at the end of the array and adds 1 to the un-commited ViewDU length
     */
    push(value: ValueOf<ElementType>): void;
    /**
     * Returns a new ListBasicTreeViewDU instance with the values from 0 to `index`.
     * To achieve it, rebinds the underlying tree zero-ing all nodes right of `chunkIindex`.
     * Also set all value right of `index` in the same chunk to 0.
     */
    sliceTo(index: number): this;
    /**
     * Same method to `type/listBasic.ts` leveraging cached nodes.
     */
    serializeToBytes(output: ByteViews, offset: number): number;
}

/**
 * List: ordered variable-length homogeneous collection, limited to N values
 *
 * Array of Basic type:
 * - Basic types are max 32 bytes long so multiple values may be packed in the same node.
 * - Basic types are never returned in a view wrapper, but their value representation
 */
declare class ListBasicType<ElementType extends BasicType<unknown>> extends ArrayType<ElementType, ListBasicTreeView<ElementType>, ListBasicTreeViewDU<ElementType>> implements ArrayBasicType<ElementType> {
    readonly elementType: ElementType;
    readonly limit: number;
    readonly typeName: string;
    readonly itemsPerChunk: number;
    readonly depth: number;
    readonly chunkDepth: number;
    readonly maxChunkCount: number;
    readonly fixedSize: null;
    readonly minSize: number;
    readonly maxSize: number;
    readonly isList = true;
    readonly isViewMutable = true;
    readonly mixInLengthBlockBytes: Uint8Array<ArrayBuffer>;
    readonly mixInLengthBuffer: Buffer<ArrayBufferLike>;
    protected readonly defaultLen = 0;
    constructor(elementType: ElementType, limit: number, opts?: ListBasicOpts);
    static named<ElementType extends BasicType<unknown>>(elementType: ElementType, limit: number, opts: Require<ListBasicOpts, "typeName">): ListBasicType<ElementType>;
    getView(tree: Tree): ListBasicTreeView<ElementType>;
    getViewDU(node: Node_2, cache?: unknown): ListBasicTreeViewDU<ElementType>;
    commitView(view: ListBasicTreeView<ElementType>): Node_2;
    commitViewDU(view: ListBasicTreeViewDU<ElementType>, hcOffset?: number, hcByLevel?: HashComputationLevel[] | null): Node_2;
    cacheOfViewDU(view: ListBasicTreeViewDU<ElementType>): unknown;
    value_serializedSize(value: ValueOf<ElementType>[]): number;
    value_serializeToBytes(output: ByteViews, offset: number, value: ValueOf<ElementType>[]): number;
    value_deserializeFromBytes(data: ByteViews, start: number, end: number): ValueOf<ElementType>[];
    tree_serializedSize(node: Node_2): number;
    tree_serializeToBytes(output: ByteViews, offset: number, node: Node_2): number;
    tree_deserializeFromBytes(data: ByteViews, start: number, end: number): Node_2;
    tree_getLength(node: Node_2): number;
    tree_setLength(tree: Tree, length: number): void;
    tree_getChunksNode(node: Node_2): Node_2;
    tree_chunksNodeOffset(): number;
    tree_setChunksNode(rootNode: Node_2, chunksNode: Node_2, newLength: number | null, hcOffset?: number, hcByLevel?: HashComputationLevel[] | null): Node_2;
    hashTreeRoot(value: ValueOf<ElementType>[]): Uint8Array;
    hashTreeRootInto(value: ValueOf<ElementType>[], output: Uint8Array, offset: number, safeCache?: boolean): void;
    protected getBlocksBytes(value: ValueOf<ElementType>[]): Uint8Array;
}

/** Expected API of this View's type. This interface allows to break a recursive dependency between types and views */
declare type ListBasicType_2<ElementType extends BasicType<unknown>> = ArrayBasicType<ElementType> & {
    readonly limit: number;
};

declare interface ListCompositeOpts {
    typeName?: string;
    cachePermanentRootStruct?: boolean;
}

declare class ListCompositeTreeView<ElementType extends CompositeType<ValueOf<ElementType>, CompositeView<ElementType>, CompositeViewDU<ElementType>>> extends ArrayCompositeTreeView<ElementType> {
    readonly type: ListCompositeType_2<ElementType>;
    protected tree: Tree;
    constructor(type: ListCompositeType_2<ElementType>, tree: Tree);
    /**
     * Adds one view element at the end of the array and adds 1 to the current Tree length.
     */
    push(view: CompositeView<ElementType>): void;
}

declare class ListCompositeTreeViewDU<ElementType extends CompositeType<ValueOf<ElementType>, CompositeView<ElementType>, CompositeViewDU<ElementType>>> extends ArrayCompositeTreeViewDU<ElementType> {
    readonly type: ListCompositeType_2<ElementType>;
    protected _rootNode: Node_2;
    constructor(type: ListCompositeType_2<ElementType>, _rootNode: Node_2, cache?: ArrayCompositeTreeViewDUCache);
    /**
     * Adds one value element at the end of the array and adds 1 to the un-commited ViewDU length
     */
    push(view: CompositeViewDU<ElementType>): void;
    /**
     * Returns a new ListCompositeTreeViewDU instance with the values from 0 to `index`.
     * The new list is equivalent to (pseudo-code):
     *
     * ```ts
     * const nodes = getChunkNodes()
     * return listFromChunkNodes(nodes.slice(0, index + 1))
     * ```
     *
     * To achieve it, rebinds the underlying tree zero-ing all nodes right of `index`.
     *
     * Note: Using index = -1, returns an empty list of length 0.
     */
    sliceTo(index: number): this;
    /**
     * Returns a new ListCompositeTreeViewDU instance with the values from `index` to the end of list
     *
     * ```ts
     * const nodes = getChunkNodes()
     * return listFromChunkNodes(node.slice(index))
     * ```
     *
     * Note: If index === n, returns an empty list of length 0
     *
     */
    sliceFrom(index: number): this;
    /**
     * Create snapshot from the first `count` elements of the list.
     */
    toSnapshot(count: number): Snapshot;
    /**
     * Same method to `type/listComposite.ts` leveraging cached nodes.
     */
    serializeToBytes(output: ByteViews, offset: number): number;
    protected rootNodeToViewDU(rootNode: Node_2): this;
}

/**
 * List: ordered variable-length homogeneous collection, limited to N values
 *
 * Array of Composite type:
 * - Composite types always take at least one chunk
 * - Composite types are always returned as views
 */
declare class ListCompositeType<ElementType extends CompositeType<any, CompositeView<ElementType>, CompositeViewDU<ElementType>>> extends ArrayType<ElementType, ListCompositeTreeView<ElementType>, ListCompositeTreeViewDU<ElementType>> implements ArrayCompositeType<ElementType> {
    readonly elementType: ElementType;
    readonly limit: number;
    readonly typeName: string;
    readonly itemsPerChunk = 1;
    readonly depth: number;
    readonly chunkDepth: number;
    readonly maxChunkCount: number;
    readonly fixedSize: null;
    readonly minSize: number;
    readonly maxSize: number;
    readonly isList = true;
    readonly isViewMutable = true;
    readonly blockArray: Uint8Array[];
    readonly mixInLengthBlockBytes: Uint8Array<ArrayBuffer>;
    readonly mixInLengthBuffer: Buffer<ArrayBufferLike>;
    protected readonly defaultLen = 0;
    constructor(elementType: ElementType, limit: number, opts?: ListCompositeOpts);
    static named<ElementType extends CompositeType<any, CompositeView<ElementType>, CompositeViewDU<ElementType>>>(elementType: ElementType, limit: number, opts: Require<ListCompositeOpts, "typeName">): ListCompositeType<ElementType>;
    getView(tree: Tree): ListCompositeTreeView<ElementType>;
    getViewDU(node: Node_2, cache?: unknown): ListCompositeTreeViewDU<ElementType>;
    commitView(view: ListCompositeTreeView<ElementType>): Node_2;
    commitViewDU(view: ListCompositeTreeViewDU<ElementType>, hcOffset?: number, hcByLevel?: HashComputationLevel[] | null): Node_2;
    cacheOfViewDU(view: ListCompositeTreeViewDU<ElementType>): unknown;
    value_serializedSize(value: ValueOf<ElementType>[]): number;
    value_serializeToBytes(output: ByteViews, offset: number, value: ValueOf<ElementType>[]): number;
    value_deserializeFromBytes(data: ByteViews, start: number, end: number, reuseBytes?: boolean): ValueOf<ElementType>[];
    tree_serializedSize(node: Node_2): number;
    tree_serializeToBytes(output: ByteViews, offset: number, node: Node_2): number;
    tree_deserializeFromBytes(data: ByteViews, start: number, end: number): Node_2;
    tree_getLength(node: Node_2): number;
    tree_setLength(tree: Tree, length: number): void;
    tree_getChunksNode(node: Node_2): Node_2;
    tree_chunksNodeOffset(): number;
    tree_setChunksNode(rootNode: Node_2, chunksNode: Node_2, newLength: number | null, hcOffset?: number, hcByLevel?: HashComputationLevel[] | null): Node_2;
    hashTreeRoot(value: ValueOf<ElementType>[]): Uint8Array;
    hashTreeRootInto(value: ValueOf<ElementType>[], output: Uint8Array, offset: number, safeCache?: boolean): void;
    protected getBlocksBytes(): Uint8Array;
}

/** Expected API of this View's type. This interface allows to break a recursive dependency between types and views */
declare type ListCompositeType_2<ElementType extends CompositeType<unknown, CompositeView<ElementType>, CompositeViewDU<ElementType>>> = ArrayCompositeType<ElementType> & {
    readonly limit: number;
};

/**
 * Specific implementation of ListBasicType for UintNumberType with some optimizations.
 */
declare class ListUintNum64Type extends ListBasicType<UintNumberType> {
    constructor(limit: number, opts?: ListBasicOpts);
    /**
     * Return a ListBasicTreeViewDU with nodes populated
     */
    toViewDU(value: number[]): ListBasicTreeViewDU<UintNumberType>;
    /**
     * No need to serialize and deserialize like in the abstract class
     */
    value_toTree(value: number[]): Node_2;
    private packedUintNum64sToNode;
}

declare type LivenessResponseData = ValueOf<typeof LivenessResponseDataType>;

declare type LivenessResponseDataList = ValueOf<typeof LivenessResponseDataListType>;

declare const LivenessResponseDataListType: ArrayType<Type<ValueOfFields<    {
index: UintNumberType;
isLive: BooleanType;
}>>, unknown, unknown>;

declare const LivenessResponseDataType: ContainerType<{
    index: UintNumberType;
    isLive: BooleanType;
}>;

declare namespace lodestar {
    export {
        getDefinitions_10 as getDefinitions,
        SyncChainDebugState,
        GossipQueueItem,
        PeerScoreStat,
        GossipPeerScoreStat,
        DirectPeer,
        RegenQueueItem,
        BlockProcessorQueueItem,
        StateCacheItem,
        LodestarNodePeer,
        BlacklistedBlock,
        LodestarThreadType,
        HistoricalSummariesResponse,
        CustodyInfo,
        Endpoints_11 as Endpoints
    }
}

declare type LodestarNodePeer = NodePeer & {
    agentVersion: string;
    status: unknown | null;
    metadata: unknown | null;
    agentClient: string;
    lastReceivedMsgUnixTsMs: number;
    lastStatusUnixTsMs: number;
    connectedUnixTsMs: number;
};

declare type LodestarThreadType = "main" | "network" | "discv5";

/**
 * biome-ignore lint/suspicious/noExplicitAny: We need to use `any` type here
 * biome-ignore-all lint/suspicious/noConsole: The logger need to use the console
 * */
declare type LogHandler = (message: string, context?: any, error?: Error) => void;

declare const MatrixEntry: ContainerType<{
    cell: ByteVectorType;
    kzgProof: ByteVectorType;
    columnIndex: UintNumberType;
    rowIndex: UintNumberType;
}>;

declare type MatrixEntry_2 = ValueOf<typeof ssz_8.MatrixEntry>;

declare const Metadata: ContainerType<{
    seqNumber: UintBigintType;
    attnets: BitVectorType;
}>;

declare type Metadata_2 = ValueOf<typeof ssz_2.Metadata>;

declare const Metadata_3: ContainerType<{
    seqNumber: UintBigintType;
    attnets: BitVectorType;
    syncnets: BitVectorType;
}>;

declare type Metadata_4 = ValueOf<typeof ssz_3.Metadata>;

declare const Metadata_5: ContainerType<{
    seqNumber: UintBigintType;
    attnets: BitVectorType;
    syncnets: BitVectorType;
    custodyGroupCount: UintNumberType;
}>;

declare type Metadata_6 = ValueOf<typeof ssz_8.Metadata>;

declare enum MetaHeader {
    Version = "Eth-Consensus-Version",
    ConsensusBlockValue = "Eth-Consensus-Block-Value",
    ExecutionPayloadBlinded = "Eth-Execution-Payload-Blinded",
    ExecutionPayloadValue = "Eth-Execution-Payload-Value",
    Finalized = "Eth-Consensus-Finalized",
    DependentRoot = "Eth-Consensus-Dependent-Root",
    ExecutionOptimistic = "Eth-Execution-Optimistic",
    ExecutionPayloadSource = "Eth-Execution-Payload-Source"
}

/**
 * A proof for multiple leaves in a tree.
 *
 * See https://github.com/ethereum/consensus-specs/blob/v1.6.1/ssz/merkle-proofs.md#merkle-multiproofs
 */
declare interface MultiProof {
    type: ProofType.multi;
    leaves: Uint8Array[];
    witnesses: Uint8Array[];
    gindices: Gindex[];
}

declare interface MultiProofInput {
    type: ProofType.multi;
    gindices: Gindex[];
}

declare type NetworkIdentity = ValueOf<typeof NetworkIdentityType> & {
    metadata: Partial<ts_7.Metadata>;
};

declare const NetworkIdentityType: ContainerType<{
    /** Cryptographic hash of a peer’s public key. [Read more](https://docs.libp2p.io/concepts/peer-id/) */
    peerId: StringType<string>;
    /** Ethereum node record. [Read more](https://eips.ethereum.org/EIPS/eip-778) */
    enr: StringType<string>;
    p2pAddresses: ArrayType<Type<string>, unknown, unknown>;
    discoveryAddresses: ArrayType<Type<string>, unknown, unknown>;
    /** Based on Ethereum Consensus [Metadata object](https://github.com/ethereum/consensus-specs/blob/v1.1.10/specs/phase0/p2p-interface.md#metadata) */
    metadata: ContainerType<{
        seqNumber: UintBigintType;
        attnets: BitVectorType;
        syncnets: BitVectorType;
    }>;
}>;

declare type NetworkName = "mainnet" | "gnosis" | "sepolia" | "hoodi" | "chiado" | "ephemery";

declare const NextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;

declare const NextSyncCommitteeBranch_2: VectorCompositeType<ByteVectorType>;

declare namespace node {
    export {
        getDefinitions_11 as getDefinitions,
        NetworkIdentityType,
        PeerCountType,
        SyncingStatusType,
        NetworkIdentity,
        PeerState,
        PeerDirection,
        NodePeerType,
        NodePeersType,
        NodePeer,
        NodePeers,
        PeersMeta,
        PeerCount,
        FilterGetPeers,
        SyncingStatus,
        NodeHealth,
        ClientCode,
        ClientVersion,
        NodeVersionV2,
        Endpoints_12 as Endpoints
    }
}

/**
 * An immutable binary merkle tree node
 */
declare abstract class Node_2 implements HashObject {
    /**
     * May be null. This is to save an extra variable to check if a node has a root or not
     */
    h0: number;
    h1: number;
    h2: number;
    h3: number;
    h4: number;
    h5: number;
    h6: number;
    h7: number;
    /** The root hash of the node */
    abstract root: Uint8Array;
    /** The root hash of the node as a `HashObject` */
    abstract rootHashObject: HashObject;
    /** The left child node */
    abstract left: Node_2;
    /** The right child node */
    abstract right: Node_2;
    constructor(h0: number, h1: number, h2: number, h3: number, h4: number, h5: number, h6: number, h7: number);
    applyHash(root: HashObject): void;
    /** Returns true if the node is a `LeafNode` */
    abstract isLeaf(): boolean;
}

declare enum NodeHealth {
    READY = 200,
    SYNCING = 206,
    NOT_INITIALIZED_OR_ISSUES = 503
}

declare type NodePeer = ValueOf<typeof NodePeerType>;

declare type NodePeers = ValueOf<typeof NodePeersType>;

declare const NodePeersType: ArrayType<Type<ValueOfFields<    {
peerId: StringType<string>;
enr: OptionalType<StringType<string>>;
lastSeenP2pAddress: StringType<string>;
state: StringType<PeerState>;
direction: OptionalType<StringType<PeerDirection>>;
}>>, unknown, unknown>;

declare const NodePeerType: ContainerType<{
    peerId: StringType<string>;
    enr: OptionalType<StringType<string>>;
    lastSeenP2pAddress: StringType<string>;
    state: StringType<PeerState>;
    direction: OptionalType<StringType<PeerDirection>>;
}>;

declare type NodeVersionV2 = {
    beaconNode: ClientVersion;
    executionClient?: ClientVersion;
};

declare type NonOptionalFields<Fields extends Record<string, Type<unknown>>> = {
    [K in keyof Fields]: NonOptionalType<Fields[K]>;
};

declare type NonOptionalType<T extends Type<unknown>> = T extends OptionalType<infer U> ? U : T;

declare type OptionalOpts = {
    typeName?: string;
};

declare type OptionalRequestInit = {
    bearerToken?: string;
};

/**
 * Optional: optional type containing either None or a type
 * - Notation: Optional[type], e.g. optional[uint64]
 * - merklizes as list of length 0 or 1, essentially acts like
 *   - like Union[none,type] or
 *   - list [], [type]
 */
declare class OptionalType<ElementType extends Type<unknown>> extends CompositeType<ValueOfType<ElementType>, ValueOfType<ElementType>, ValueOfType<ElementType>> {
    readonly elementType: ElementType;
    readonly typeName: string;
    readonly depth: number;
    readonly maxChunkCount: number;
    readonly fixedSize: null;
    readonly minSize: number;
    readonly maxSize: number;
    readonly isList = true;
    readonly isViewMutable = true;
    readonly mixInLengthBlockBytes: Uint8Array<ArrayBuffer>;
    readonly mixInLengthBuffer: Buffer<ArrayBufferLike>;
    constructor(elementType: ElementType, opts?: OptionalOpts);
    static named<ElementType extends Type<unknown>>(elementType: ElementType, opts: Require<OptionalOpts, "typeName">): OptionalType<ElementType>;
    defaultValue(): ValueOfType<ElementType>;
    getView(tree: Tree): ValueOfType<ElementType>;
    getViewDU(node: Node_2): ValueOfType<ElementType>;
    commitView(view: ValueOfType<ElementType>): Node_2;
    commitViewDU(view: ValueOfType<ElementType>, hcOffset?: number, hcByLevel?: HashComputationLevel[] | null): Node_2;
    cacheOfViewDU(): unknown;
    value_serializedSize(value: ValueOfType<ElementType>): number;
    value_serializeToBytes(output: ByteViews, offset: number, value: ValueOfType<ElementType>): number;
    value_deserializeFromBytes(data: ByteViews, start: number, end: number, reuseBytes?: boolean): ValueOfType<ElementType>;
    tree_serializedSize(node: Node_2): number;
    tree_serializeToBytes(output: ByteViews, offset: number, node: Node_2): number;
    tree_deserializeFromBytes(data: ByteViews, start: number, end: number): Node_2;
    hashTreeRoot(value: ValueOfType<ElementType>): Uint8Array;
    hashTreeRootInto(value: ValueOfType<ElementType>, output: Uint8Array, offset: number): void;
    protected getBlocksBytes(value: ValueOfType<ElementType>): Uint8Array;
    getPropertyGindex(prop: JsonPathProp): Gindex | null;
    getPropertyType(prop: JsonPathProp): Type<unknown>;
    getIndexProperty(index: number): JsonPathProp | null;
    tree_createProofGindexes(node: Node_2, jsonPaths: JsonPath[]): Gindex[];
    tree_getLeafGindices(rootGindex: bigint, rootNode?: Node_2): Gindex[];
    fromJson(json: unknown): ValueOfType<ElementType>;
    toJson(value: ValueOfType<ElementType>): unknown | Record<string, unknown>;
    clone(value: ValueOfType<ElementType>): ValueOfType<ElementType>;
    equals(a: ValueOfType<ElementType>, b: ValueOfType<ElementType>): boolean;
}

declare const ParticipationFlags: UintNumberType;

declare type PathParams = Record<string, string | number>;

declare const PayloadAttestation: ContainerType<{
    aggregationBits: BitVectorType;
    data: ContainerType<{
        beaconBlockRoot: ByteVectorType;
        slot: UintNumberType;
        payloadPresent: BooleanType;
        blobDataAvailable: BooleanType;
    }>;
    signature: ByteVectorType;
}>;

declare type PayloadAttestation_2 = ValueOf<typeof ssz_9.PayloadAttestation>;

declare const PayloadAttestationData: ContainerType<{
    beaconBlockRoot: ByteVectorType;
    slot: UintNumberType;
    payloadPresent: BooleanType;
    blobDataAvailable: BooleanType;
}>;

declare type PayloadAttestationData_2 = ValueOf<typeof ssz_9.PayloadAttestationData>;

declare type PayloadAttestationList = ValueOf<typeof PayloadAttestationListType>;

declare const PayloadAttestationListType: ArrayType<Type<ValueOfFields<    {
aggregationBits: BitVectorType;
data: ContainerType<    {
beaconBlockRoot: ByteVectorType;
slot: UintNumberType;
payloadPresent: BooleanType;
blobDataAvailable: BooleanType;
}>;
signature: ByteVectorType;
}>>, unknown, unknown>;

declare const PayloadAttestationMessage: ContainerType<{
    validatorIndex: UintNumberType;
    data: ContainerType<{
        beaconBlockRoot: ByteVectorType;
        slot: UintNumberType;
        payloadPresent: BooleanType;
        blobDataAvailable: BooleanType;
    }>;
    signature: ByteVectorType;
}>;

declare type PayloadAttestationMessage_2 = ValueOf<typeof ssz_9.PayloadAttestationMessage>;

declare type PayloadAttestationMessageList = ValueOf<typeof PayloadAttestationMessageListType>;

declare const PayloadAttestationMessageListType: ArrayType<Type<ValueOfFields<    {
validatorIndex: UintNumberType;
data: ContainerType<    {
beaconBlockRoot: ByteVectorType;
slot: UintNumberType;
payloadPresent: BooleanType;
blobDataAvailable: BooleanType;
}>;
signature: ByteVectorType;
}>>, unknown, unknown>;

declare const PayloadAttributes: ContainerType<{
    timestamp: UintNumberType;
    prevRandao: ByteVectorType;
    suggestedFeeRecipient: StringType<string>;
}>;

declare const PayloadAttributes_2: ContainerType<{
    timestamp: UintNumberType;
    prevRandao: ByteVectorType;
    suggestedFeeRecipient: StringType<string>;
    withdrawals: ListCompositeType<ContainerType<{
        index: UintNumberType;
        validatorIndex: UintNumberType;
        address: ExecutionAddressType;
        amount: UintBigintType;
    }>>;
}>;

declare const PayloadAttributes_3: ContainerType<{
    timestamp: UintNumberType;
    prevRandao: ByteVectorType;
    suggestedFeeRecipient: StringType<string>;
    withdrawals: ListCompositeType<ContainerType<{
        index: UintNumberType;
        validatorIndex: UintNumberType;
        address: ExecutionAddressType;
        amount: UintBigintType;
    }>>;
    parentBeaconBlockRoot: ByteVectorType;
}>;

declare const PayloadAttributes_4: ContainerType<{
    timestamp: UintNumberType;
    prevRandao: ByteVectorType;
    suggestedFeeRecipient: StringType<string>;
    withdrawals: ListCompositeType<ContainerType<{
        index: UintNumberType;
        validatorIndex: UintNumberType;
        address: ExecutionAddressType;
        amount: UintBigintType;
    }>>;
    parentBeaconBlockRoot: ByteVectorType;
}>;

declare const PayloadAttributes_5: ContainerType<{
    timestamp: UintNumberType;
    prevRandao: ByteVectorType;
    suggestedFeeRecipient: StringType<string>;
    withdrawals: ListCompositeType<ContainerType<{
        index: UintNumberType;
        validatorIndex: UintNumberType;
        address: ExecutionAddressType;
        amount: UintBigintType;
    }>>;
    parentBeaconBlockRoot: ByteVectorType;
    slotNumber: UintNumberType;
}>;

declare type PayloadAttributes_6 = ValueOf<typeof ssz_9.PayloadAttributes>;

declare const PayloadTimelinessCommittee: VectorBasicType<UintNumberType>;

declare type PayloadTimelinessCommittee_2 = ValueOf<typeof ssz_9.PayloadTimelinessCommittee>;

declare type PeerCount = ValueOf<typeof PeerCountType>;

declare const PeerCountType: ContainerType<{
    disconnected: UintNumberType;
    connecting: UintNumberType;
    connected: UintNumberType;
    disconnecting: UintNumberType;
}>;

declare type PeerDirection = "inbound" | "outbound";

declare type PeerScoreStat = {
    peerId: string;
    lodestarScore: number;
    gossipScore: number;
    ignoreNegativeGossipScore: boolean;
    score: number;
    lastUpdate: number;
};

declare type PeersMeta = {
    count: number;
};

declare type PeerState = "disconnected" | "connecting" | "connected" | "disconnecting";

declare const PendingAttestation: ContainerType<{
    aggregationBits: BitListType;
    data: ContainerType<{
        slot: UintNumberType;
        index: UintNumberType;
        beaconBlockRoot: ByteVectorType;
        source: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
        }>;
        target: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
        }>;
    }>;
    inclusionDelay: UintNumberType;
    proposerIndex: UintNumberType;
}>;

declare type PendingAttestation_2 = ValueOf<typeof ssz_2.PendingAttestation>;

declare const PendingConsolidation: ContainerType<{
    sourceIndex: UintNumberType;
    targetIndex: UintNumberType;
}>;

declare type PendingConsolidation_2 = ValueOf<typeof ssz_7.PendingConsolidation>;

declare const PendingConsolidations: ListCompositeType<ContainerType<{
    sourceIndex: UintNumberType;
    targetIndex: UintNumberType;
}>>;

declare type PendingConsolidations_2 = ValueOf<typeof ssz_7.PendingConsolidations>;

declare const PendingDeposit: ContainerType<{
    pubkey: ByteVectorType;
    withdrawalCredentials: ByteVectorType;
    amount: UintNumberType;
    signature: ByteVectorType;
    slot: UintNumberType;
}>;

declare type PendingDeposit_2 = ValueOf<typeof ssz_7.PendingDeposit>;

declare const PendingDeposits: ListCompositeType<ContainerType<{
    pubkey: ByteVectorType;
    withdrawalCredentials: ByteVectorType;
    amount: UintNumberType;
    signature: ByteVectorType;
    slot: UintNumberType;
}>>;

declare type PendingDeposits_2 = ValueOf<typeof ssz_7.PendingDeposits>;

declare const PendingPartialWithdrawal: ContainerType<{
    validatorIndex: UintNumberType;
    amount: UintBigintType;
    withdrawableEpoch: UintNumberType;
}>;

declare type PendingPartialWithdrawal_2 = ValueOf<typeof ssz_7.PendingPartialWithdrawal>;

declare const PendingPartialWithdrawals: ListCompositeType<ContainerType<{
    validatorIndex: UintNumberType;
    amount: UintBigintType;
    withdrawableEpoch: UintNumberType;
}>>;

declare type PendingPartialWithdrawals_2 = ValueOf<typeof ssz_7.PendingPartialWithdrawals>;

declare const Ping: UintBigintType;

declare type Ping_2 = ValueOf<typeof ssz_2.Ping>;

declare enum PointFormat {
    compressed = "compressed",
    uncompressed = "uncompressed"
}

declare namespace pool {
    export {
        getDefinitions_2 as getDefinitions,
        Endpoints_4 as Endpoints
    }
}

declare const PowBlock: ContainerType<{
    blockHash: ByteVectorType;
    parentHash: ByteVectorType;
    totalDifficulty: UintBigintType;
}>;

/** @deprecated */
declare type PowBlock_2 = ValueOf<typeof ssz_4.PowBlock>;

declare enum PresetName {
    mainnet = "mainnet",
    minimal = "minimal",
    gnosis = "gnosis"
}

declare interface ProcessUpdateOpts {
    allowForcedUpdates?: boolean;
    updateHeadersOnForcedUpdate?: boolean;
}

declare type ProduceBlockV3Meta = ValueOf<typeof ProduceBlockV3MetaType> & {
    /** Lodestar-specific (non-standardized) value */
    executionPayloadSource: ProducedBlockSource;
};

declare const ProduceBlockV3MetaType: ContainerType<{
    version: StringType<ForkName>;
    /** Specifies whether the response contains full or blinded block */
    executionPayloadBlinded: BooleanType;
    /** Execution payload value in Wei */
    executionPayloadValue: UintBigintType;
    /** Consensus rewards paid to the proposer for this block, in Wei */
    consensusBlockValue: UintBigintType;
}>;

declare type ProduceBlockV4Meta = ValueOf<typeof ProduceBlockV4MetaType>;

declare const ProduceBlockV4MetaType: ContainerType<{
    version: StringType<ForkName>;
    /** Consensus rewards paid to the proposer for this block, in Wei */
    consensusBlockValue: UintBigintType;
}>;

declare type ProducedBlobSidecars = Omit<BlobSidecars_2, "signedBlockHeader" | "kzgCommitmentInclusionProof">;

/** Handy enum to represent the block production source */
declare enum ProducedBlockSource {
    builder = "builder",
    engine = "engine"
}

declare type Proof = SingleProof | TreeOffsetProof | MultiProof | CompactMultiProof;

declare namespace proof {
    export {
        getDefinitions_12 as getDefinitions,
        CompactMultiProofType,
        Endpoints_13 as Endpoints
    }
}

declare type ProofInput = SingleProofInput | TreeOffsetProofInput | MultiProofInput | CompactMultiProofInput;

declare enum ProofType {
    single = "single",
    treeOffset = "treeOffset",
    multi = "multi",
    compactMulti = "compactMulti"
}

declare type ProposerDuty = ValueOf<typeof ProposerDutyType>;

declare type ProposerDutyList = ValueOf<typeof ProposerDutyListType>;

declare const ProposerDutyListType: ArrayType<Type<ValueOfFields<    {
slot: UintNumberType;
validatorIndex: UintNumberType;
pubkey: ByteVectorType;
}>>, unknown, unknown>;

declare const ProposerDutyType: ContainerType<{
    slot: UintNumberType;
    validatorIndex: UintNumberType;
    pubkey: ByteVectorType;
}>;

declare const ProposerLookahead: VectorBasicType<UintNumberType>;

declare type ProposerLookahead_2 = ValueOf<typeof ssz_8.ProposerLookahead>;

declare const ProposerPreferences: ContainerType<{
    dependentRoot: ByteVectorType;
    proposalSlot: UintNumberType;
    validatorIndex: UintNumberType;
    feeRecipient: ExecutionAddressType;
    gasLimit: UintNumberType;
}>;

declare type ProposerPreferences_2 = ValueOf<typeof ssz_9.ProposerPreferences>;

declare type ProposerPreparationData = ValueOf<typeof ProposerPreparationDataType>;

declare type ProposerPreparationDataList = ValueOf<typeof ProposerPreparationDataListType>;

declare const ProposerPreparationDataListType: ArrayType<Type<ValueOfFields<    {
validatorIndex: UintNumberType;
feeRecipient: StringType<string>;
}>>, unknown, unknown>;

declare const ProposerPreparationDataType: ContainerType<{
    validatorIndex: UintNumberType;
    feeRecipient: StringType<string>;
}>;

declare const ProposerSlashing: ContainerType<{
    signedHeader1: ContainerType<{
        message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        signature: ByteVectorType;
    }>;
    signedHeader2: ContainerType<{
        message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        signature: ByteVectorType;
    }>;
}>;

declare type ProposerSlashing_2 = ValueOf<typeof ssz_2.ProposerSlashing>;

declare type ProposerSlashingList = ValueOf<typeof ProposerSlashingListType>;

declare const ProposerSlashingListType: ArrayType<Type<ValueOfFields<    {
signedHeader1: ContainerType<    {
message: ContainerType<    {
slot: UintBigintType;
proposerIndex: UintNumberType;
parentRoot: ByteVectorType;
stateRoot: ByteVectorType;
bodyRoot: ByteVectorType;
}>;
signature: ByteVectorType;
}>;
signedHeader2: ContainerType<    {
message: ContainerType<    {
slot: UintBigintType;
proposerIndex: UintNumberType;
parentRoot: ByteVectorType;
stateRoot: ByteVectorType;
bodyRoot: ByteVectorType;
}>;
signature: ByteVectorType;
}>;
}>>, unknown, unknown>;

declare type ProtoNodeList = ValueOf<typeof ProtoNodeListType>;

declare const ProtoNodeListType: ArrayType<Type<ValueOfFields<    {
executionPayloadBlockHash: StringType<string>;
executionPayloadNumber: UintNumberType;
executionStatus: StringType<string>;
slot: UintNumberType;
blockRoot: StringType<string>;
parentRoot: StringType<string>;
stateRoot: StringType<string>;
targetRoot: StringType<string>;
timeliness: BooleanType;
justifiedEpoch: UintNumberType;
justifiedRoot: StringType<string>;
finalizedEpoch: UintNumberType;
finalizedRoot: StringType<string>;
unrealizedJustifiedEpoch: UintNumberType;
unrealizedJustifiedRoot: StringType<string>;
unrealizedFinalizedEpoch: UintNumberType;
unrealizedFinalizedRoot: StringType<string>;
parent: StringType<string>;
weight: UintNumberType;
bestChild: StringType<string>;
bestDescendant: StringType<string>;
}>>, unknown, unknown>;

declare type PtcDuty = ValueOf<typeof PtcDutyType>;

declare type PtcDutyList = ValueOf<typeof PtcDutyListType>;

declare const PtcDutyListType: ArrayType<Type<ValueOfFields<    {
/** Public key of the validator in the registry  */
pubkey: ByteVectorType;
/** Index of validator in the registry. */
validatorIndex: UintNumberType;
/** The slot at which the validator must perform PTC duties. */
slot: UintNumberType;
}>>, unknown, unknown>;

declare const PtcDutyType: ContainerType<{
    /** Public key of the validator in the registry  */
    pubkey: ByteVectorType;
    /** Index of validator in the registry. */
    validatorIndex: UintNumberType;
    /** The slot at which the validator must perform PTC duties. */
    slot: UintNumberType;
}>;

declare const PtcWindow: VectorCompositeType<VectorBasicType<UintNumberType>>;

declare type PtcWindow_2 = ValueOf<typeof ssz_9.PtcWindow>;

declare class PublicKey {
    private constructor();
    /** @param type Only for impl `blst-native`. Defaults to `CoordType.jacobian` */
    static fromBytes(bytes: Uint8Array, type?: CoordType, validate?: boolean): PublicKey;
    static fromHex(hex: string): PublicKey;
    static aggregate(publicKeys: PublicKeyArg[]): PublicKey;
    /** @param format Defaults to `PointFormat.compressed` */
    toBytes(format?: PointFormat): Uint8Array;
    toHex(format?: PointFormat): string;
    multiplyBy(bytes: Uint8Array): PublicKey;
}

declare type PublicKeyArg = PublicKey | Uint8Array;

declare type QueryParams = Record<string, string | number | boolean | (string | number)[]>;

declare const RandaoMixes: VectorCompositeType<ByteVectorType>;

declare type RandaoResponse = ValueOf<typeof RandaoResponseType>;

declare const RandaoResponseType: ContainerType<{
    randao: ByteVectorType;
}>;

declare type RawBody = {
    type: WireFormat.json;
    value: unknown;
} | {
    type: WireFormat.ssz;
    value: Uint8Array;
} | {
    type?: never;
    value?: never;
};

declare type RegenQueueItem = {
    key: string;
    args: unknown;
    addedTimeMs: number;
};

/**
 * Handles translation between `Endpoint["args"]` and `Endpoint["request"]`
 */
declare type RequestCodec<E extends Endpoint> = E["method"] extends "GET" ? RequestWithoutBodyCodec<E> : "body" extends keyof E["request"] ? RequestWithBodyCodec<E> : RequestWithoutBodyCodec<E>;

declare type RequestData<P extends PathParams = PathParams, Q extends QueryParams = QueryParams, H extends HeaderParams = HeaderParams> = {
    params?: P;
    query?: Q;
    headers?: H;
};

declare type RequestWithBodyCodec<E extends Endpoint> = JsonRequestMethods<E> & SszRequestMethods<E> & {
    schema: SchemaDefinition<E["request"]>;
    /** Support ssz-only or json-only requests */
    onlySupport?: WireFormat;
};

/** Encode / decode requests to & from function params, as well as schema definitions */
declare type RequestWithoutBodyCodec<E extends Endpoint> = {
    writeReq: (p: E["args"]) => E["request"];
    parseReq: (r: E["request"]) => E["args"];
    schema: SchemaDefinition<E["request"]>;
};

declare type Require<T, K extends keyof T> = T & Required<Pick<T, K>>;

declare type RequireSchema<T> = {
    [K in keyof T]-?: Schema;
};

declare type ResponseCodec<E extends Endpoint> = {
    data: ResponseDataCodec<E["return"], E["meta"]>;
    meta: ResponseMetadataCodec<E["meta"]>;
    /** Occasionally, json responses require an extra transformation to separate the data from metadata */
    transform?: {
        toResponse: (data: unknown, meta: unknown) => unknown;
        fromResponse: (resp: unknown) => {
            data: E["return"];
        } & (E["meta"] extends EmptyMeta ? {
            meta?: never;
        } : {
            meta: E["meta"];
        });
    };
    /** Support ssz-only or json-only responses */
    onlySupport?: WireFormat;
    /** Indicator used to handle empty responses */
    isEmpty?: true;
};

declare type ResponseDataCodec<T, M> = {
    toJson: (data: T, meta: M) => unknown;
    fromJson: (data: unknown, meta: M) => T;
    serialize: (data: T, meta: M) => Uint8Array;
    deserialize: (data: Uint8Array, meta: any) => T;
};

declare type ResponseMetadataCodec<T> = {
    toJson: (val: T) => unknown;
    fromJson: (val: unknown) => T;
    toHeadersObject: (val: T) => Record<string, string>;
    fromHeaders: (headers: HeadersExtra) => T;
};

declare namespace rewards {
    export {
        getDefinitions_4 as getDefinitions,
        Endpoints_6 as Endpoints
    }
}

export declare namespace rewards_2 {
    export {
        BlockRewardsType,
        AttestationsRewardType,
        IdealAttestationsRewardsType,
        TotalAttestationsRewardsType,
        AttestationsRewardsType,
        SyncCommitteeRewardsType,
        BlockRewards,
        AttestationsReward,
        IdealAttestationsReward,
        TotalAttestationsReward,
        AttestationsRewards,
        SyncCommitteeRewards
    }
}

declare const Root: ByteVectorType;

declare type Root_2 = Bytes32_2;

/** Common non-spec type to represent roots as strings */
declare type RootHex = string;

declare type RootResponse = ValueOf<typeof RootResponseType>;

declare const RootResponseType: ContainerType<{
    root: ByteVectorType;
}>;

/**
 * Top-level definition of a route used by both the client and server
 * - url and method
 * - request and response codec
 * - request json schema
 */
declare type RouteDefinition<E extends Endpoint> = {
    url: string;
    method: E["method"];
    req: RequestCodec<E>;
    resp: ResponseCodec<E>;
    init?: ExtraRequestInit;
};

/** Route definition with computed extra properties */
declare type RouteDefinitionExtra<E extends Endpoint> = RouteDefinition<E> & {
    operationId: string;
    urlFormatter: (args: Record<string, string | number>) => string;
};

declare type RouteDefinitions<Es extends Record<string, Endpoint>> = {
    [K in keyof Es]: RouteDefinition<Es[K]>;
};

declare namespace routes {
    export {
        beacon,
        config,
        debug,
        events,
        lightclient,
        lodestar,
        node,
        proof,
        validator,
        Endpoints
    }
}

declare const RowIndex: UintNumberType;

export declare enum RunStatusCode {
    uninitialized = 0,
    started = 1,
    syncing = 2,
    stopped = 3
}

declare enum Schema {
    Uint = 0,
    UintRequired = 1,
    UintArray = 2,
    String = 3,
    StringRequired = 4,
    StringArray = 5,
    StringArrayRequired = 6,
    UintOrStringRequired = 7,
    UintOrStringArray = 8,
    Object = 9,
    ObjectArray = 10,
    AnyArray = 11,
    Boolean = 12
}

declare type SchemaDefinition<ReqType extends Endpoint["request"]> = (ReqType["params"] extends PathParams ? {
    params: RequireSchema<ReqType["params"]>;
} : {
    params?: never;
}) & (ReqType["query"] extends QueryParams ? {
    query: RequireSchema<ReqType["query"]>;
} : {
    query?: never;
}) & (ReqType["headers"] extends HeaderParams ? {
    headers: RequireSchema<ReqType["headers"]>;
} : {
    headers?: never;
}) & (ReqType extends {
    body: unknown;
} ? {
    body: Schema;
} : {
    body?: never;
});

declare function serializeSyncCommittee(syncCommittee: SyncCommitteeFast): ts_2.SyncCommittee;

declare const SignedAggregateAndProof: ContainerType<{
    message: ContainerType<{
        aggregatorIndex: UintNumberType;
        aggregate: ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        selectionProof: ByteVectorType;
    }>;
    signature: ByteVectorType;
}>;

declare type SignedAggregateAndProof_2 = ValueOf<typeof ssz_2.SignedAggregateAndProof>;

declare const SignedAggregateAndProof_3: ContainerType<{
    message: ContainerType<{
        aggregatorIndex: UintNumberType;
        aggregate: ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
            committeeBits: BitVectorType;
        }>;
        selectionProof: ByteVectorType;
    }>;
    signature: ByteVectorType;
}>;

declare type SignedAggregateAndProof_4 = ValueOf<typeof ssz_7.SignedAggregateAndProof>;

declare type SignedAggregateAndProofList = SignedAggregateAndProofListPhase0 | SignedAggregateAndProofListElectra;

declare type SignedAggregateAndProofListElectra = ValueOf<typeof SignedAggregateAndProofListElectraType>;

declare const SignedAggregateAndProofListElectraType: ArrayType<Type<ValueOfFields<    {
message: ContainerType<{
aggregatorIndex: UintNumberType;
aggregate: ContainerType<{
aggregationBits: BitListType;
data: ContainerType<{
slot: UintNumberType;
index: UintNumberType;
beaconBlockRoot: ByteVectorType;
source: ContainerType<{
epoch: UintNumberType;
root: ByteVectorType;
}>;
target: ContainerType<{
epoch: UintNumberType;
root: ByteVectorType;
}>;
}>;
signature: ByteVectorType;
committeeBits: BitVectorType;
}>;
selectionProof: ByteVectorType;
}>;
signature: ByteVectorType;
}>>, unknown, unknown>;

declare type SignedAggregateAndProofListPhase0 = ValueOf<typeof SignedAggregateAndProofListPhase0Type>;

declare const SignedAggregateAndProofListPhase0Type: ArrayType<Type<ValueOfFields<    {
message: ContainerType<{
aggregatorIndex: UintNumberType;
aggregate: ContainerType<{
aggregationBits: BitListType;
data: ContainerType<{
slot: UintNumberType;
index: UintNumberType;
beaconBlockRoot: ByteVectorType;
source: ContainerType<{
epoch: UintNumberType;
root: ByteVectorType;
}>;
target: ContainerType<{
epoch: UintNumberType;
root: ByteVectorType;
}>;
}>;
signature: ByteVectorType;
}>;
selectionProof: ByteVectorType;
}>;
signature: ByteVectorType;
}>>, unknown, unknown>;

declare const SignedBeaconBlock: ContainerType<{
    message: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        body: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
            }>>;
        }>;
    }>;
    signature: ByteVectorType;
}>;

declare type SignedBeaconBlock_10 = ValueOf<typeof ssz_6.SignedBeaconBlock>;

declare const SignedBeaconBlock_11: ContainerType<{
    message: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        body: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
                committeeBits: BitVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
            }>>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            executionPayload: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactions: ListCompositeType<ByteListType>;
                withdrawals: ListCompositeType<ContainerType<{
                    index: UintNumberType;
                    validatorIndex: UintNumberType;
                    address: ExecutionAddressType;
                    amount: UintBigintType;
                }>>;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            blsToExecutionChanges: ListCompositeType<ContainerType<{
                message: ContainerType<{
                    validatorIndex: UintNumberType;
                    fromBlsPubkey: ByteVectorType;
                    toExecutionAddress: ExecutionAddressType;
                }>;
                signature: ByteVectorType;
            }>>;
            blobKzgCommitments: ListCompositeType<ByteVectorType>;
            executionRequests: ContainerType<{
                deposits: ListCompositeType<ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    index: UintBigintType;
                }>>;
                withdrawals: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    validatorPubkey: ByteVectorType;
                    amount: UintBigintType;
                }>>;
                consolidations: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    sourcePubkey: ByteVectorType;
                    targetPubkey: ByteVectorType;
                }>>;
            }>;
        }>;
    }>;
    signature: ByteVectorType;
}>;

declare type SignedBeaconBlock_12 = ValueOf<typeof ssz_7.SignedBeaconBlock>;

declare const SignedBeaconBlock_13: ContainerType<{
    message: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        body: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
                committeeBits: BitVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
            }>>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            executionPayload: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactions: ListCompositeType<ByteListType>;
                withdrawals: ListCompositeType<ContainerType<{
                    index: UintNumberType;
                    validatorIndex: UintNumberType;
                    address: ExecutionAddressType;
                    amount: UintBigintType;
                }>>;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            blsToExecutionChanges: ListCompositeType<ContainerType<{
                message: ContainerType<{
                    validatorIndex: UintNumberType;
                    fromBlsPubkey: ByteVectorType;
                    toExecutionAddress: ExecutionAddressType;
                }>;
                signature: ByteVectorType;
            }>>;
            blobKzgCommitments: ListCompositeType<ByteVectorType>;
            executionRequests: ContainerType<{
                deposits: ListCompositeType<ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    index: UintBigintType;
                }>>;
                withdrawals: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    validatorPubkey: ByteVectorType;
                    amount: UintBigintType;
                }>>;
                consolidations: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    sourcePubkey: ByteVectorType;
                    targetPubkey: ByteVectorType;
                }>>;
            }>;
        }>;
    }>;
    signature: ByteVectorType;
}>;

declare type SignedBeaconBlock_14 = ValueOf<typeof ssz_8.SignedBeaconBlock>;

declare const SignedBeaconBlock_15: ContainerType<{
    message: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        body: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
                committeeBits: BitVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
            }>>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            blsToExecutionChanges: ListCompositeType<ContainerType<{
                message: ContainerType<{
                    validatorIndex: UintNumberType;
                    fromBlsPubkey: ByteVectorType;
                    toExecutionAddress: ExecutionAddressType;
                }>;
                signature: ByteVectorType;
            }>>;
            signedExecutionPayloadBid: ContainerType<{
                message: ContainerType<{
                    parentBlockHash: ByteVectorType;
                    parentBlockRoot: ByteVectorType;
                    blockHash: ByteVectorType;
                    prevRandao: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    gasLimit: UintBigintType;
                    builderIndex: UintNumberType;
                    slot: UintNumberType;
                    value: UintNumberType;
                    executionPayment: UintNumberType;
                    blobKzgCommitments: ListCompositeType<ByteVectorType>;
                    executionRequestsRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
            payloadAttestations: ListCompositeType<ContainerType<{
                aggregationBits: BitVectorType;
                data: ContainerType<{
                    beaconBlockRoot: ByteVectorType;
                    slot: UintNumberType;
                    payloadPresent: BooleanType;
                    blobDataAvailable: BooleanType;
                }>;
                signature: ByteVectorType;
            }>>;
            parentExecutionRequests: ContainerType<{
                deposits: ListCompositeType<ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    index: UintBigintType;
                }>>;
                withdrawals: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    validatorPubkey: ByteVectorType;
                    amount: UintBigintType;
                }>>;
                consolidations: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    sourcePubkey: ByteVectorType;
                    targetPubkey: ByteVectorType;
                }>>;
            }>;
        }>;
    }>;
    signature: ByteVectorType;
}>;

declare type SignedBeaconBlock_16 = ValueOf<typeof ssz_9.SignedBeaconBlock>;

declare type SignedBeaconBlock_17<F extends ForkAll = ForkAll> = TypesByFork[F]["SignedBeaconBlock"];

declare type SignedBeaconBlock_2 = ValueOf<typeof ssz_2.SignedBeaconBlock>;

declare const SignedBeaconBlock_3: ContainerType<{
    message: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        body: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
            }>>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
        }>;
    }>;
    signature: ByteVectorType;
}>;

declare type SignedBeaconBlock_4 = ValueOf<typeof ssz_3.SignedBeaconBlock>;

declare const SignedBeaconBlock_5: ContainerType<{
    message: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        body: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
            }>>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            executionPayload: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactions: ListCompositeType<ByteListType>;
            }>;
        }>;
    }>;
    signature: ByteVectorType;
}>;

declare type SignedBeaconBlock_6 = ValueOf<typeof ssz_4.SignedBeaconBlock>;

declare const SignedBeaconBlock_7: ContainerType<{
    message: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        body: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
            }>>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            executionPayload: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactions: ListCompositeType<ByteListType>;
                withdrawals: ListCompositeType<ContainerType<{
                    index: UintNumberType;
                    validatorIndex: UintNumberType;
                    address: ExecutionAddressType;
                    amount: UintBigintType;
                }>>;
            }>;
            blsToExecutionChanges: ListCompositeType<ContainerType<{
                message: ContainerType<{
                    validatorIndex: UintNumberType;
                    fromBlsPubkey: ByteVectorType;
                    toExecutionAddress: ExecutionAddressType;
                }>;
                signature: ByteVectorType;
            }>>;
        }>;
    }>;
    signature: ByteVectorType;
}>;

declare type SignedBeaconBlock_8 = ValueOf<typeof ssz_5.SignedBeaconBlock>;

declare const SignedBeaconBlock_9: ContainerType<{
    message: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        body: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
            }>>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            executionPayload: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactions: ListCompositeType<ByteListType>;
                withdrawals: ListCompositeType<ContainerType<{
                    index: UintNumberType;
                    validatorIndex: UintNumberType;
                    address: ExecutionAddressType;
                    amount: UintBigintType;
                }>>;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            blsToExecutionChanges: ListCompositeType<ContainerType<{
                message: ContainerType<{
                    validatorIndex: UintNumberType;
                    fromBlsPubkey: ByteVectorType;
                    toExecutionAddress: ExecutionAddressType;
                }>;
                signature: ByteVectorType;
            }>>;
            blobKzgCommitments: ListCompositeType<ByteVectorType>;
        }>;
    }>;
    signature: ByteVectorType;
}>;

declare const SignedBeaconBlockHeader: ContainerType<{
    message: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
    }>;
    signature: ByteVectorType;
}>;

declare type SignedBeaconBlockHeader_2 = ValueOf<typeof ssz_2.SignedBeaconBlockHeader>;

/** Same as `SignedBeaconBlockHeader` but slot is not bounded by the clock and must be a bigint */
declare const SignedBeaconBlockHeaderBigint: ContainerType<{
    message: ContainerType<{
        slot: UintBigintType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
    }>;
    signature: ByteVectorType;
}>;

declare type SignedBeaconBlockHeaderBigint_2 = ValueOf<typeof ssz_2.SignedBeaconBlockHeaderBigint>;

declare const SignedBlindedBeaconBlock: ContainerType<{
    message: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        body: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
            }>>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            executionPayloadHeader: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
            }>;
        }>;
    }>;
    signature: ByteVectorType;
}>;

declare type SignedBlindedBeaconBlock_2 = ValueOf<typeof ssz_4.SignedBlindedBeaconBlock>;

declare const SignedBlindedBeaconBlock_3: ContainerType<{
    message: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        body: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
            }>>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            executionPayloadHeader: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
            }>;
            blsToExecutionChanges: ListCompositeType<ContainerType<{
                message: ContainerType<{
                    validatorIndex: UintNumberType;
                    fromBlsPubkey: ByteVectorType;
                    toExecutionAddress: ExecutionAddressType;
                }>;
                signature: ByteVectorType;
            }>>;
        }>;
    }>;
    signature: ByteVectorType;
}>;

declare type SignedBlindedBeaconBlock_4 = ValueOf<typeof ssz_5.SignedBlindedBeaconBlock>;

declare const SignedBlindedBeaconBlock_5: ContainerType<{
    message: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        body: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
            }>>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            executionPayloadHeader: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            blsToExecutionChanges: ListCompositeType<ContainerType<{
                message: ContainerType<{
                    validatorIndex: UintNumberType;
                    fromBlsPubkey: ByteVectorType;
                    toExecutionAddress: ExecutionAddressType;
                }>;
                signature: ByteVectorType;
            }>>;
            blobKzgCommitments: ListCompositeType<ByteVectorType>;
        }>;
    }>;
    signature: ByteVectorType;
}>;

declare type SignedBlindedBeaconBlock_6 = ValueOf<typeof ssz_6.SignedBlindedBeaconBlock>;

declare const SignedBlindedBeaconBlock_7: ContainerType<{
    message: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        body: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                    message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintBigintType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
                committeeBits: BitVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
            }>>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            executionPayloadHeader: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            blsToExecutionChanges: ListCompositeType<ContainerType<{
                message: ContainerType<{
                    validatorIndex: UintNumberType;
                    fromBlsPubkey: ByteVectorType;
                    toExecutionAddress: ExecutionAddressType;
                }>;
                signature: ByteVectorType;
            }>>;
            blobKzgCommitments: ListCompositeType<ByteVectorType>;
            executionRequests: ContainerType<{
                deposits: ListCompositeType<ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    index: UintBigintType;
                }>>;
                withdrawals: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    validatorPubkey: ByteVectorType;
                    amount: UintBigintType;
                }>>;
                consolidations: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    sourcePubkey: ByteVectorType;
                    targetPubkey: ByteVectorType;
                }>>;
            }>;
        }>;
    }>;
    signature: ByteVectorType;
}>;

declare type SignedBlindedBeaconBlock_8 = ValueOf<typeof ssz_7.SignedBlindedBeaconBlock>;

declare type SignedBlindedBeaconBlock_9<F extends ForkPostBellatrix = ForkPostBellatrix> = TypesByFork[F]["SignedBlindedBeaconBlock"];

declare const SignedBlockContents: ContainerType<{
    signedBlock: ContainerType<{
        message: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            body: ContainerType<{
                randaoReveal: ByteVectorType;
                eth1Data: ContainerType<{
                    depositRoot: ByteVectorType;
                    depositCount: UintNumberType;
                    blockHash: ByteVectorType;
                }>;
                graffiti: ByteVectorType;
                proposerSlashings: ListCompositeType<ContainerType<{
                    signedHeader1: ContainerType<{
                        message: ContainerType<{
                            slot: UintBigintType;
                            proposerIndex: UintNumberType;
                            parentRoot: ByteVectorType;
                            stateRoot: ByteVectorType;
                            bodyRoot: ByteVectorType;
                        }>;
                        signature: ByteVectorType;
                    }>;
                    signedHeader2: ContainerType<{
                        message: ContainerType<{
                            slot: UintBigintType;
                            proposerIndex: UintNumberType;
                            parentRoot: ByteVectorType;
                            stateRoot: ByteVectorType;
                            bodyRoot: ByteVectorType;
                        }>;
                        signature: ByteVectorType;
                    }>;
                }>>;
                attesterSlashings: ListCompositeType<ContainerType<{
                    attestation1: ContainerType<{
                        attestingIndices: ListBasicType<UintNumberType>;
                        data: ContainerType<{
                            slot: UintBigintType;
                            index: UintBigintType;
                            beaconBlockRoot: ByteVectorType;
                            source: ContainerType<{
                                epoch: UintBigintType;
                                root: ByteVectorType;
                            }>;
                            target: ContainerType<{
                                epoch: UintBigintType;
                                root: ByteVectorType;
                            }>;
                        }>;
                        signature: ByteVectorType;
                    }>;
                    attestation2: ContainerType<{
                        attestingIndices: ListBasicType<UintNumberType>;
                        data: ContainerType<{
                            slot: UintBigintType;
                            index: UintBigintType;
                            beaconBlockRoot: ByteVectorType;
                            source: ContainerType<{
                                epoch: UintBigintType;
                                root: ByteVectorType;
                            }>;
                            target: ContainerType<{
                                epoch: UintBigintType;
                                root: ByteVectorType;
                            }>;
                        }>;
                        signature: ByteVectorType;
                    }>;
                }>>;
                attestations: ListCompositeType<ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                        slot: UintNumberType;
                        index: UintNumberType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintNumberType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintNumberType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>>;
                deposits: ListCompositeType<ContainerType<{
                    proof: VectorCompositeType<ByteVectorType>;
                    data: ContainerType<{
                        pubkey: ByteVectorType;
                        withdrawalCredentials: ByteVectorType;
                        amount: UintNumberType;
                        signature: ByteVectorType;
                    }>;
                }>>;
                voluntaryExits: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                        epoch: UintNumberType;
                        validatorIndex: UintNumberType;
                    }>;
                    signature: ByteVectorType;
                }>>;
                syncAggregate: ContainerType<{
                    syncCommitteeBits: BitVectorType;
                    syncCommitteeSignature: ByteVectorType;
                }>;
                executionPayload: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactions: ListCompositeType<ByteListType>;
                    withdrawals: ListCompositeType<ContainerType<{
                        index: UintNumberType;
                        validatorIndex: UintNumberType;
                        address: ExecutionAddressType;
                        amount: UintBigintType;
                    }>>;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                blsToExecutionChanges: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                        validatorIndex: UintNumberType;
                        fromBlsPubkey: ByteVectorType;
                        toExecutionAddress: ExecutionAddressType;
                    }>;
                    signature: ByteVectorType;
                }>>;
                blobKzgCommitments: ListCompositeType<ByteVectorType>;
            }>;
        }>;
        signature: ByteVectorType;
    }>;
    kzgProofs: ListCompositeType<ByteVectorType>;
    blobs: ListCompositeType<ByteVectorType>;
}>;

declare type SignedBlockContents_2 = ValueOf<typeof ssz_6.SignedBlockContents>;

declare const SignedBlockContents_3: ContainerType<{
    signedBlock: ContainerType<{
        message: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            body: ContainerType<{
                randaoReveal: ByteVectorType;
                eth1Data: ContainerType<{
                    depositRoot: ByteVectorType;
                    depositCount: UintNumberType;
                    blockHash: ByteVectorType;
                }>;
                graffiti: ByteVectorType;
                proposerSlashings: ListCompositeType<ContainerType<{
                    signedHeader1: ContainerType<{
                        message: ContainerType<{
                            slot: UintBigintType;
                            proposerIndex: UintNumberType;
                            parentRoot: ByteVectorType;
                            stateRoot: ByteVectorType;
                            bodyRoot: ByteVectorType;
                        }>;
                        signature: ByteVectorType;
                    }>;
                    signedHeader2: ContainerType<{
                        message: ContainerType<{
                            slot: UintBigintType;
                            proposerIndex: UintNumberType;
                            parentRoot: ByteVectorType;
                            stateRoot: ByteVectorType;
                            bodyRoot: ByteVectorType;
                        }>;
                        signature: ByteVectorType;
                    }>;
                }>>;
                attesterSlashings: ListCompositeType<ContainerType<{
                    attestation1: ContainerType<{
                        attestingIndices: ListBasicType<UintNumberType>;
                        data: ContainerType<{
                            slot: UintBigintType;
                            index: UintBigintType;
                            beaconBlockRoot: ByteVectorType;
                            source: ContainerType<{
                                epoch: UintBigintType;
                                root: ByteVectorType;
                            }>;
                            target: ContainerType<{
                                epoch: UintBigintType;
                                root: ByteVectorType;
                            }>;
                        }>;
                        signature: ByteVectorType;
                    }>;
                    attestation2: ContainerType<{
                        attestingIndices: ListBasicType<UintNumberType>;
                        data: ContainerType<{
                            slot: UintBigintType;
                            index: UintBigintType;
                            beaconBlockRoot: ByteVectorType;
                            source: ContainerType<{
                                epoch: UintBigintType;
                                root: ByteVectorType;
                            }>;
                            target: ContainerType<{
                                epoch: UintBigintType;
                                root: ByteVectorType;
                            }>;
                        }>;
                        signature: ByteVectorType;
                    }>;
                }>>;
                attestations: ListCompositeType<ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                        slot: UintNumberType;
                        index: UintNumberType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintNumberType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintNumberType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                    committeeBits: BitVectorType;
                }>>;
                deposits: ListCompositeType<ContainerType<{
                    proof: VectorCompositeType<ByteVectorType>;
                    data: ContainerType<{
                        pubkey: ByteVectorType;
                        withdrawalCredentials: ByteVectorType;
                        amount: UintNumberType;
                        signature: ByteVectorType;
                    }>;
                }>>;
                voluntaryExits: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                        epoch: UintNumberType;
                        validatorIndex: UintNumberType;
                    }>;
                    signature: ByteVectorType;
                }>>;
                syncAggregate: ContainerType<{
                    syncCommitteeBits: BitVectorType;
                    syncCommitteeSignature: ByteVectorType;
                }>;
                executionPayload: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactions: ListCompositeType<ByteListType>;
                    withdrawals: ListCompositeType<ContainerType<{
                        index: UintNumberType;
                        validatorIndex: UintNumberType;
                        address: ExecutionAddressType;
                        amount: UintBigintType;
                    }>>;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                blsToExecutionChanges: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                        validatorIndex: UintNumberType;
                        fromBlsPubkey: ByteVectorType;
                        toExecutionAddress: ExecutionAddressType;
                    }>;
                    signature: ByteVectorType;
                }>>;
                blobKzgCommitments: ListCompositeType<ByteVectorType>;
                executionRequests: ContainerType<{
                    deposits: ListCompositeType<ContainerType<{
                        pubkey: ByteVectorType;
                        withdrawalCredentials: ByteVectorType;
                        amount: UintNumberType;
                        signature: ByteVectorType;
                        index: UintBigintType;
                    }>>;
                    withdrawals: ListCompositeType<ContainerType<{
                        sourceAddress: ExecutionAddressType;
                        validatorPubkey: ByteVectorType;
                        amount: UintBigintType;
                    }>>;
                    consolidations: ListCompositeType<ContainerType<{
                        sourceAddress: ExecutionAddressType;
                        sourcePubkey: ByteVectorType;
                        targetPubkey: ByteVectorType;
                    }>>;
                }>;
            }>;
        }>;
        signature: ByteVectorType;
    }>;
    kzgProofs: ListCompositeType<ByteVectorType>;
    blobs: ListCompositeType<ByteVectorType>;
}>;

declare type SignedBlockContents_4 = ValueOf<typeof ssz_7.SignedBlockContents>;

declare const SignedBlockContents_5: ContainerType<{
    signedBlock: ContainerType<{
        message: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            body: ContainerType<{
                randaoReveal: ByteVectorType;
                eth1Data: ContainerType<{
                    depositRoot: ByteVectorType;
                    depositCount: UintNumberType;
                    blockHash: ByteVectorType;
                }>;
                graffiti: ByteVectorType;
                proposerSlashings: ListCompositeType<ContainerType<{
                    signedHeader1: ContainerType<{
                        message: ContainerType<{
                            slot: UintBigintType;
                            proposerIndex: UintNumberType;
                            parentRoot: ByteVectorType;
                            stateRoot: ByteVectorType;
                            bodyRoot: ByteVectorType;
                        }>;
                        signature: ByteVectorType;
                    }>;
                    signedHeader2: ContainerType<{
                        message: ContainerType<{
                            slot: UintBigintType;
                            proposerIndex: UintNumberType;
                            parentRoot: ByteVectorType;
                            stateRoot: ByteVectorType;
                            bodyRoot: ByteVectorType;
                        }>;
                        signature: ByteVectorType;
                    }>;
                }>>;
                attesterSlashings: ListCompositeType<ContainerType<{
                    attestation1: ContainerType<{
                        attestingIndices: ListBasicType<UintNumberType>;
                        data: ContainerType<{
                            slot: UintBigintType;
                            index: UintBigintType;
                            beaconBlockRoot: ByteVectorType;
                            source: ContainerType<{
                                epoch: UintBigintType;
                                root: ByteVectorType;
                            }>;
                            target: ContainerType<{
                                epoch: UintBigintType;
                                root: ByteVectorType;
                            }>;
                        }>;
                        signature: ByteVectorType;
                    }>;
                    attestation2: ContainerType<{
                        attestingIndices: ListBasicType<UintNumberType>;
                        data: ContainerType<{
                            slot: UintBigintType;
                            index: UintBigintType;
                            beaconBlockRoot: ByteVectorType;
                            source: ContainerType<{
                                epoch: UintBigintType;
                                root: ByteVectorType;
                            }>;
                            target: ContainerType<{
                                epoch: UintBigintType;
                                root: ByteVectorType;
                            }>;
                        }>;
                        signature: ByteVectorType;
                    }>;
                }>>;
                attestations: ListCompositeType<ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                        slot: UintNumberType;
                        index: UintNumberType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintNumberType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintNumberType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                    committeeBits: BitVectorType;
                }>>;
                deposits: ListCompositeType<ContainerType<{
                    proof: VectorCompositeType<ByteVectorType>;
                    data: ContainerType<{
                        pubkey: ByteVectorType;
                        withdrawalCredentials: ByteVectorType;
                        amount: UintNumberType;
                        signature: ByteVectorType;
                    }>;
                }>>;
                voluntaryExits: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                        epoch: UintNumberType;
                        validatorIndex: UintNumberType;
                    }>;
                    signature: ByteVectorType;
                }>>;
                syncAggregate: ContainerType<{
                    syncCommitteeBits: BitVectorType;
                    syncCommitteeSignature: ByteVectorType;
                }>;
                executionPayload: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactions: ListCompositeType<ByteListType>;
                    withdrawals: ListCompositeType<ContainerType<{
                        index: UintNumberType;
                        validatorIndex: UintNumberType;
                        address: ExecutionAddressType;
                        amount: UintBigintType;
                    }>>;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                blsToExecutionChanges: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                        validatorIndex: UintNumberType;
                        fromBlsPubkey: ByteVectorType;
                        toExecutionAddress: ExecutionAddressType;
                    }>;
                    signature: ByteVectorType;
                }>>;
                blobKzgCommitments: ListCompositeType<ByteVectorType>;
                executionRequests: ContainerType<{
                    deposits: ListCompositeType<ContainerType<{
                        pubkey: ByteVectorType;
                        withdrawalCredentials: ByteVectorType;
                        amount: UintNumberType;
                        signature: ByteVectorType;
                        index: UintBigintType;
                    }>>;
                    withdrawals: ListCompositeType<ContainerType<{
                        sourceAddress: ExecutionAddressType;
                        validatorPubkey: ByteVectorType;
                        amount: UintBigintType;
                    }>>;
                    consolidations: ListCompositeType<ContainerType<{
                        sourceAddress: ExecutionAddressType;
                        sourcePubkey: ByteVectorType;
                        targetPubkey: ByteVectorType;
                    }>>;
                }>;
            }>;
        }>;
        signature: ByteVectorType;
    }>;
    kzgProofs: ListCompositeType<ByteVectorType>;
    blobs: ListCompositeType<ByteVectorType>;
}>;

declare type SignedBlockContents_6 = ValueOf<typeof ssz_8.SignedBlockContents>;

declare type SignedBlockContents_7<F extends ForkAll = ForkAll> = TypesByFork[F]["SignedBlockContents"];

declare const SignedBLSToExecutionChange: ContainerType<{
    message: ContainerType<{
        validatorIndex: UintNumberType;
        fromBlsPubkey: ByteVectorType;
        toExecutionAddress: ExecutionAddressType;
    }>;
    signature: ByteVectorType;
}>;

declare type SignedBLSToExecutionChange_2 = ValueOf<typeof ssz_5.SignedBLSToExecutionChange>;

declare type SignedBLSToExecutionChangeList = ValueOf<typeof SignedBLSToExecutionChangeListType>;

declare const SignedBLSToExecutionChangeListType: ArrayType<Type<ValueOfFields<    {
message: ContainerType<    {
validatorIndex: UintNumberType;
fromBlsPubkey: ByteVectorType;
toExecutionAddress: ExecutionAddressType;
}>;
signature: ByteVectorType;
}>>, unknown, unknown>;

declare const SignedBuilderBid: ContainerType<{
    message: ContainerType<{
        header: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
        }>;
        value: UintBigintType;
        pubkey: ByteVectorType;
    }>;
    signature: ByteVectorType;
}>;

declare type SignedBuilderBid_2 = ValueOf<typeof ssz_4.SignedBuilderBid>;

declare const SignedBuilderBid_3: ContainerType<{
    message: ContainerType<{
        header: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
        }>;
        value: UintBigintType;
        pubkey: ByteVectorType;
    }>;
    signature: ByteVectorType;
}>;

declare type SignedBuilderBid_4 = ValueOf<typeof ssz_5.SignedBuilderBid>;

declare const SignedBuilderBid_5: ContainerType<{
    message: ContainerType<{
        header: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
        }>;
        blobKzgCommitments: ListCompositeType<ByteVectorType>;
        value: UintBigintType;
        pubkey: ByteVectorType;
    }>;
    signature: ByteVectorType;
}>;

declare type SignedBuilderBid_6 = ValueOf<typeof ssz_6.SignedBuilderBid>;

declare const SignedBuilderBid_7: ContainerType<{
    message: ContainerType<{
        header: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
        }>;
        blobKzgCommitments: ListCompositeType<ByteVectorType>;
        executionRequests: ContainerType<{
            deposits: ListCompositeType<ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                index: UintBigintType;
            }>>;
            withdrawals: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                validatorPubkey: ByteVectorType;
                amount: UintBigintType;
            }>>;
            consolidations: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                sourcePubkey: ByteVectorType;
                targetPubkey: ByteVectorType;
            }>>;
        }>;
        value: UintBigintType;
        pubkey: ByteVectorType;
    }>;
    signature: ByteVectorType;
}>;

declare type SignedBuilderBid_8 = ValueOf<typeof ssz_7.SignedBuilderBid>;

declare const SignedContributionAndProof: ContainerType<{
    message: ContainerType<{
        aggregatorIndex: UintNumberType;
        contribution: ContainerType<{
            slot: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            subcommitteeIndex: UintNumberType;
            aggregationBits: BitVectorType;
            signature: ByteVectorType;
        }>;
        selectionProof: ByteVectorType;
    }>;
    signature: ByteVectorType;
}>;

declare type SignedContributionAndProof_2 = ValueOf<typeof ssz_3.SignedContributionAndProof>;

declare type SignedContributionAndProofList = ValueOf<typeof SignedContributionAndProofListType>;

declare const SignedContributionAndProofListType: ArrayType<Type<ValueOfFields<    {
message: ContainerType<{
aggregatorIndex: UintNumberType;
contribution: ContainerType<{
slot: UintNumberType;
beaconBlockRoot: ByteVectorType;
subcommitteeIndex: UintNumberType;
aggregationBits: BitVectorType;
signature: ByteVectorType;
}>;
selectionProof: ByteVectorType;
}>;
signature: ByteVectorType;
}>>, unknown, unknown>;

declare const SignedExecutionPayloadBid: ContainerType<{
    message: ContainerType<{
        parentBlockHash: ByteVectorType;
        parentBlockRoot: ByteVectorType;
        blockHash: ByteVectorType;
        prevRandao: ByteVectorType;
        feeRecipient: ExecutionAddressType;
        gasLimit: UintBigintType;
        builderIndex: UintNumberType;
        slot: UintNumberType;
        value: UintNumberType;
        executionPayment: UintNumberType;
        blobKzgCommitments: ListCompositeType<ByteVectorType>;
        executionRequestsRoot: ByteVectorType;
    }>;
    signature: ByteVectorType;
}>;

declare type SignedExecutionPayloadBid_2 = ValueOf<typeof ssz_9.SignedExecutionPayloadBid>;

declare const SignedExecutionPayloadEnvelope: ContainerType<{
    message: ContainerType<{
        payload: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactions: ListCompositeType<ByteListType>;
            withdrawals: ListCompositeType<ContainerType<{
                index: UintNumberType;
                validatorIndex: UintNumberType;
                address: ExecutionAddressType;
                amount: UintBigintType;
            }>>;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
            blockAccessList: ByteListType;
            slotNumber: UintNumberType;
        }>;
        executionRequests: ContainerType<{
            deposits: ListCompositeType<ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                index: UintBigintType;
            }>>;
            withdrawals: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                validatorPubkey: ByteVectorType;
                amount: UintBigintType;
            }>>;
            consolidations: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                sourcePubkey: ByteVectorType;
                targetPubkey: ByteVectorType;
            }>>;
        }>;
        builderIndex: UintNumberType;
        beaconBlockRoot: ByteVectorType;
        parentBeaconBlockRoot: ByteVectorType;
    }>;
    signature: ByteVectorType;
}>;

declare type SignedExecutionPayloadEnvelope_2 = ValueOf<typeof ssz_9.SignedExecutionPayloadEnvelope>;

declare const SignedProposerPreferences: ContainerType<{
    message: ContainerType<{
        dependentRoot: ByteVectorType;
        proposalSlot: UintNumberType;
        validatorIndex: UintNumberType;
        feeRecipient: ExecutionAddressType;
        gasLimit: UintNumberType;
    }>;
    signature: ByteVectorType;
}>;

declare type SignedProposerPreferences_2 = ValueOf<typeof ssz_9.SignedProposerPreferences>;

declare const SignedValidatorRegistrationV1: ContainerType<{
    message: ContainerType<{
        feeRecipient: ExecutionAddressType;
        gasLimit: UintNumberType;
        timestamp: UintNumberType;
        pubkey: ByteVectorType;
    }>;
    signature: ByteVectorType;
}>;

declare type SignedValidatorRegistrationV1_2 = ValueOf<typeof ssz_4.SignedValidatorRegistrationV1>;

declare type SignedValidatorRegistrationV1List = ValueOf<typeof SignedValidatorRegistrationV1ListType>;

declare const SignedValidatorRegistrationV1ListType: ArrayType<Type<ValueOfFields<    {
message: ContainerType<{
feeRecipient: ExecutionAddressType;
gasLimit: UintNumberType;
timestamp: UintNumberType;
pubkey: ByteVectorType;
}>;
signature: ByteVectorType;
}>>, unknown, unknown>;

declare const SignedVoluntaryExit: ContainerType<{
    message: ContainerType<{
        epoch: UintNumberType;
        validatorIndex: UintNumberType;
    }>;
    signature: ByteVectorType;
}>;

declare type SignedVoluntaryExit_2 = ValueOf<typeof ssz_2.SignedVoluntaryExit>;

declare type SignedVoluntaryExitList = ValueOf<typeof SignedVoluntaryExitListType>;

declare const SignedVoluntaryExitListType: ArrayType<Type<ValueOfFields<    {
message: ContainerType<    {
epoch: UintNumberType;
validatorIndex: UintNumberType;
}>;
signature: ByteVectorType;
}>>, unknown, unknown>;

declare const SigningData: ContainerType<{
    objectRoot: ByteVectorType;
    domain: ByteVectorType;
}>;

declare type SigningData_2 = ValueOf<typeof ssz_2.SigningData>;

declare const SingleAttestation: ContainerType<{
    aggregationBits: BitListType;
    data: ContainerType<{
        slot: UintNumberType;
        index: UintNumberType;
        beaconBlockRoot: ByteVectorType;
        source: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
        }>;
        target: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
        }>;
    }>;
    signature: ByteVectorType;
}>;

declare const SingleAttestation_2: ContainerType<{
    committeeIndex: UintNumberType;
    attesterIndex: UintNumberType;
    data: ContainerType<{
        slot: UintNumberType;
        index: UintNumberType;
        beaconBlockRoot: ByteVectorType;
        source: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
        }>;
        target: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
        }>;
    }>;
    signature: ByteVectorType;
}>;

declare type SingleAttestation_3 = ValueOf<typeof ssz_7.SingleAttestation>;

declare type SingleAttestation_4<F extends ForkName = ForkAll> = TypesByFork[F]["SingleAttestation"];

/**
 * A common merkle proof.
 * A proof for a single leaf in a tree.
 */
declare interface SingleProof {
    type: ProofType.single;
    gindex: Gindex;
    leaf: Uint8Array;
    witnesses: Uint8Array[];
}

declare interface SingleProofInput {
    type: ProofType.single;
    gindex: Gindex;
}

/**
 * This is initially a Gwei (BigInt) vector, however since Nov 2023 it's converted to UintNum64 (number) vector in the state transition because:
 * - state.slashings[nextEpoch % EPOCHS_PER_SLASHINGS_VECTOR] is reset per epoch in processSlashingsReset()
 * - max slashed validators per epoch is SLOTS_PER_EPOCH * MAX_ATTESTER_SLASHINGS * MAX_VALIDATORS_PER_COMMITTEE which is 32 * 2 * 2048 = 131072 on mainnet
 * - with that and 32_000_000_000 MAX_EFFECTIVE_BALANCE or 2048_000_000_000 MAX_EFFECTIVE_BALANCE_ELECTRA, it still fits in a number given that Math.floor(Number.MAX_SAFE_INTEGER / 32_000_000_000) = 281474
 * - we don't need to compute the total slashings from state.slashings, it's handled by totalSlashingsByIncrement in EpochCache
 */
declare const Slashings: VectorBasicType<UintNumberType>;

/**
 * Use JS Number for performance, values must be limited to 2**52-1.
 * Slot is a time unit, so in all usages it's bounded by the clock, ensuring < 2**53-1
 */
declare const Slot: UintNumberType;

declare type Slot_2 = UintNumInf64;

/** Returns the slot if the internal clock were advanced by `toleranceSec`. */
declare function slotWithFutureTolerance(config: ChainConfig, genesisTime: number, toleranceSec: number): Slot_2;

/**
 * A snapshot contains the minimum amount of information needed to reconstruct a merkleized list, for the purposes of appending more items.
 * Note: This does not contain list elements, rather only contains intermediate merkle nodes.
 * This is used primarily for PartialListCompositeType.
 */
declare type Snapshot = {
    finalized: Uint8Array[];
    root: Uint8Array;
    count: number;
};

declare type Spec = SpecJson;

declare type SpecJson = Record<string, string | Record<string, string>[]>;

declare const SSEPayloadAttributes: ContainerType<{
    proposerIndex: UintNumberType;
    proposalSlot: UintNumberType;
    parentBlockNumber: UintNumberType;
    parentBlockRoot: ByteVectorType;
    parentBlockHash: ByteVectorType;
    payloadAttributes: ContainerType<{
        timestamp: UintNumberType;
        prevRandao: ByteVectorType;
        suggestedFeeRecipient: StringType<string>;
    }>;
}>;

declare type SSEPayloadAttributes_10 = ValueOf<typeof ssz_9.SSEPayloadAttributes>;

declare type SSEPayloadAttributes_11<F extends ForkPostBellatrix = ForkPostBellatrix> = TypesByFork[F]["SSEPayloadAttributes"];

declare type SSEPayloadAttributes_2 = ValueOf<typeof ssz_4.SSEPayloadAttributes>;

declare const SSEPayloadAttributes_3: ContainerType<{
    proposerIndex: UintNumberType;
    proposalSlot: UintNumberType;
    parentBlockNumber: UintNumberType;
    parentBlockRoot: ByteVectorType;
    parentBlockHash: ByteVectorType;
    payloadAttributes: ContainerType<{
        timestamp: UintNumberType;
        prevRandao: ByteVectorType;
        suggestedFeeRecipient: StringType<string>;
        withdrawals: ListCompositeType<ContainerType<{
            index: UintNumberType;
            validatorIndex: UintNumberType;
            address: ExecutionAddressType;
            amount: UintBigintType;
        }>>;
    }>;
}>;

declare type SSEPayloadAttributes_4 = ValueOf<typeof ssz_5.SSEPayloadAttributes>;

declare const SSEPayloadAttributes_5: ContainerType<{
    proposerIndex: UintNumberType;
    proposalSlot: UintNumberType;
    parentBlockNumber: UintNumberType;
    parentBlockRoot: ByteVectorType;
    parentBlockHash: ByteVectorType;
    payloadAttributes: ContainerType<{
        timestamp: UintNumberType;
        prevRandao: ByteVectorType;
        suggestedFeeRecipient: StringType<string>;
        withdrawals: ListCompositeType<ContainerType<{
            index: UintNumberType;
            validatorIndex: UintNumberType;
            address: ExecutionAddressType;
            amount: UintBigintType;
        }>>;
        parentBeaconBlockRoot: ByteVectorType;
    }>;
}>;

declare type SSEPayloadAttributes_6 = ValueOf<typeof ssz_6.SSEPayloadAttributes>;

declare const SSEPayloadAttributes_7: ContainerType<{
    proposerIndex: UintNumberType;
    proposalSlot: UintNumberType;
    parentBlockNumber: UintNumberType;
    parentBlockRoot: ByteVectorType;
    parentBlockHash: ByteVectorType;
    payloadAttributes: ContainerType<{
        timestamp: UintNumberType;
        prevRandao: ByteVectorType;
        suggestedFeeRecipient: StringType<string>;
        withdrawals: ListCompositeType<ContainerType<{
            index: UintNumberType;
            validatorIndex: UintNumberType;
            address: ExecutionAddressType;
            amount: UintBigintType;
        }>>;
        parentBeaconBlockRoot: ByteVectorType;
    }>;
}>;

declare type SSEPayloadAttributes_8 = ValueOf<typeof ssz_7.SSEPayloadAttributes>;

declare const SSEPayloadAttributes_9: ContainerType<{
    proposerIndex: UintNumberType;
    proposalSlot: UintNumberType;
    parentBlockNumber: UintNumberType;
    parentBlockRoot: ByteVectorType;
    parentBlockHash: ByteVectorType;
    payloadAttributes: ContainerType<{
        timestamp: UintNumberType;
        prevRandao: ByteVectorType;
        suggestedFeeRecipient: StringType<string>;
        withdrawals: ListCompositeType<ContainerType<{
            index: UintNumberType;
            validatorIndex: UintNumberType;
            address: ExecutionAddressType;
            amount: UintBigintType;
        }>>;
        parentBeaconBlockRoot: ByteVectorType;
        slotNumber: UintNumberType;
    }>;
}>;

declare const SSEPayloadAttributesCommon: ContainerType<{
    proposerIndex: UintNumberType;
    proposalSlot: UintNumberType;
    parentBlockNumber: UintNumberType;
    parentBlockRoot: ByteVectorType;
    parentBlockHash: ByteVectorType;
}>;

declare namespace ssz {
    export {
        Boolean_2 as Boolean,
        Byte,
        Bytes4,
        Bytes8,
        Bytes20,
        Bytes32,
        Bytes48,
        Bytes96,
        Uint8,
        Uint16,
        Uint32,
        UintNum64,
        UintNumInf64_2 as UintNumInf64,
        UintBn64,
        UintBn128,
        UintBn256,
        Slot,
        Epoch_2 as Epoch,
        EpochInf,
        SyncPeriod,
        CommitteeIndex,
        SubcommitteeIndex,
        BuilderIndex,
        ValidatorIndex,
        WithdrawalIndex,
        DepositIndex,
        Gwei,
        Wei,
        Root,
        BlobIndex,
        Version,
        DomainType,
        ForkDigest,
        BLSPubkey,
        BLSSignature,
        Domain,
        ParticipationFlags,
        ExecutionAddress,
        ColumnIndex,
        CustodyIndex,
        RowIndex
    }
}

declare namespace ssz_2 {
    export {
        AttestationSubnets_2 as AttestationSubnets,
        BeaconBlockHeader,
        BeaconBlockHeaderBigint,
        SignedBeaconBlockHeader,
        SignedBeaconBlockHeaderBigint,
        Checkpoint,
        CheckpointBigint,
        CommitteeBits,
        CommitteeIndices,
        DepositMessage,
        DepositData,
        DepositDataRootList,
        DepositEvent,
        Eth1Data,
        Eth1DataVotes,
        Eth1DataOrdered,
        Eth1Block,
        Fork,
        ForkData,
        ENRForkID,
        HistoricalBlockRoots,
        HistoricalStateRoots,
        HistoricalBatch,
        HistoricalBatchRoots,
        Validator,
        Validators,
        Balances,
        RandaoMixes,
        Slashings,
        JustificationBits,
        AttestationData,
        AttestationDataBigint,
        IndexedAttestation,
        IndexedAttestationBigint,
        PendingAttestation,
        SigningData,
        Attestation,
        SingleAttestation,
        AttesterSlashing,
        Deposit,
        ProposerSlashing,
        VoluntaryExit,
        SignedVoluntaryExit,
        BeaconBlockBody,
        BeaconBlock,
        SignedBeaconBlock,
        EpochAttestations,
        BeaconState,
        CommitteeAssignment,
        AggregateAndProof,
        SignedAggregateAndProof,
        Status,
        Goodbye,
        Ping,
        Metadata,
        BeaconBlocksByRangeRequest,
        Genesis
    }
}

declare namespace ssz_3 {
    export {
        SyncSubnets_2 as SyncSubnets,
        FinalityBranch,
        CurrentSyncCommitteeBranch,
        NextSyncCommitteeBranch,
        Metadata_3 as Metadata,
        SyncCommittee,
        SyncCommitteeMessage,
        SyncCommitteeContribution,
        ContributionAndProof,
        SignedContributionAndProof,
        SyncAggregatorSelectionData,
        SyncCommitteeBits,
        SyncAggregate,
        BeaconBlockBody_3 as BeaconBlockBody,
        BeaconBlock_3 as BeaconBlock,
        SignedBeaconBlock_3 as SignedBeaconBlock,
        EpochParticipation,
        InactivityScores,
        BeaconState_3 as BeaconState,
        LightClientHeader,
        LightClientBootstrap,
        LightClientUpdate,
        LightClientFinalityUpdate_2 as LightClientFinalityUpdate,
        LightClientOptimisticUpdate,
        LightClientUpdatesByRange,
        LightClientStore
    }
}

declare namespace ssz_4 {
    export {
        Transaction_2 as Transaction,
        Transactions,
        CommonExecutionPayloadType,
        ExecutionPayload,
        ExecutionPayloadHeader,
        BeaconBlockBody_5 as BeaconBlockBody,
        BeaconBlock_5 as BeaconBlock,
        SignedBeaconBlock_5 as SignedBeaconBlock,
        PowBlock,
        BeaconState_5 as BeaconState,
        BlindedBeaconBlockBody,
        BlindedBeaconBlock,
        SignedBlindedBeaconBlock,
        ValidatorRegistrationV1,
        SignedValidatorRegistrationV1,
        BuilderBid,
        SignedBuilderBid,
        PayloadAttributes,
        SSEPayloadAttributesCommon,
        SSEPayloadAttributes
    }
}

declare namespace ssz_5 {
    export {
        ExecutionBranch,
        Withdrawal_2 as Withdrawal,
        BLSToExecutionChange,
        SignedBLSToExecutionChange,
        Withdrawals,
        ExecutionPayload_3 as ExecutionPayload,
        ExecutionPayloadHeader_3 as ExecutionPayloadHeader,
        BLSToExecutionChanges,
        BeaconBlockBody_7 as BeaconBlockBody,
        BeaconBlock_7 as BeaconBlock,
        SignedBeaconBlock_7 as SignedBeaconBlock,
        BuilderBid_3 as BuilderBid,
        SignedBuilderBid_3 as SignedBuilderBid,
        HistoricalSummary,
        HistoricalSummaries,
        BeaconState_7 as BeaconState,
        BlindedBeaconBlockBody_3 as BlindedBeaconBlockBody,
        BlindedBeaconBlock_3 as BlindedBeaconBlock,
        SignedBlindedBeaconBlock_3 as SignedBlindedBeaconBlock,
        LightClientHeader_3 as LightClientHeader,
        LightClientBootstrap_3 as LightClientBootstrap,
        LightClientUpdate_3 as LightClientUpdate,
        LightClientFinalityUpdate_4 as LightClientFinalityUpdate,
        LightClientOptimisticUpdate_3 as LightClientOptimisticUpdate,
        LightClientStore_3 as LightClientStore,
        PayloadAttributes_2 as PayloadAttributes,
        SSEPayloadAttributes_3 as SSEPayloadAttributes
    }
}

declare namespace ssz_6 {
    export {
        G1Point,
        G2Point,
        BLSFieldElement,
        KZGCommitment,
        KZGProof_2 as KZGProof,
        Blob_2 as Blob,
        Blobs,
        BlindedBlob,
        BlindedBlobs,
        VersionedHash,
        BlobKzgCommitments,
        KZGProofs,
        BlobSidecarsByRangeRequest,
        BlobIdentifier,
        ExecutionPayload_5 as ExecutionPayload,
        ExecutionPayloadHeader_5 as ExecutionPayloadHeader,
        BeaconBlockBody_9 as BeaconBlockBody,
        BeaconBlock_9 as BeaconBlock,
        SignedBeaconBlock_9 as SignedBeaconBlock,
        KzgCommitmentInclusionProof,
        BlobSidecar,
        BlobSidecars,
        BlobsBundle,
        BlindedBeaconBlockBody_5 as BlindedBeaconBlockBody,
        BlindedBeaconBlock_5 as BlindedBeaconBlock,
        SignedBlindedBeaconBlock_5 as SignedBlindedBeaconBlock,
        BuilderBid_5 as BuilderBid,
        SignedBuilderBid_5 as SignedBuilderBid,
        ExecutionPayloadAndBlobsBundle,
        BeaconState_9 as BeaconState,
        LightClientHeader_5 as LightClientHeader,
        LightClientBootstrap_5 as LightClientBootstrap,
        LightClientUpdate_5 as LightClientUpdate,
        LightClientFinalityUpdate_6 as LightClientFinalityUpdate,
        LightClientOptimisticUpdate_5 as LightClientOptimisticUpdate,
        LightClientStore_5 as LightClientStore,
        PayloadAttributes_3 as PayloadAttributes,
        SSEPayloadAttributes_5 as SSEPayloadAttributes,
        BlockContents,
        SignedBlockContents
    }
}

declare namespace ssz_7 {
    export {
        CurrentSyncCommitteeBranch_2 as CurrentSyncCommitteeBranch,
        FinalityBranch_2 as FinalityBranch,
        NextSyncCommitteeBranch_2 as NextSyncCommitteeBranch,
        AggregationBits,
        CommitteeBits_2 as CommitteeBits,
        AttestingIndices,
        Attestation_4 as Attestation,
        SingleAttestation_2 as SingleAttestation,
        IndexedAttestation_3 as IndexedAttestation,
        IndexedAttestationBigint_3 as IndexedAttestationBigint,
        AttesterSlashing_3 as AttesterSlashing,
        AggregateAndProof_3 as AggregateAndProof,
        SignedAggregateAndProof_3 as SignedAggregateAndProof,
        DepositRequest,
        DepositRequests,
        WithdrawalRequest,
        WithdrawalRequests,
        ConsolidationRequest,
        ConsolidationRequests,
        ExecutionRequests,
        ExecutionPayloadHeader_7 as ExecutionPayloadHeader,
        ExecutionPayload_7 as ExecutionPayload,
        BeaconBlockBody_11 as BeaconBlockBody,
        BeaconBlock_11 as BeaconBlock,
        SignedBeaconBlock_11 as SignedBeaconBlock,
        BlindedBeaconBlockBody_7 as BlindedBeaconBlockBody,
        BlindedBeaconBlock_7 as BlindedBeaconBlock,
        SignedBlindedBeaconBlock_7 as SignedBlindedBeaconBlock,
        BuilderBid_7 as BuilderBid,
        SignedBuilderBid_7 as SignedBuilderBid,
        PendingDeposit,
        PendingDeposits,
        PendingPartialWithdrawal,
        PendingPartialWithdrawals,
        PendingConsolidation,
        PendingConsolidations,
        BeaconState_11 as BeaconState,
        LightClientBootstrap_7 as LightClientBootstrap,
        LightClientUpdate_7 as LightClientUpdate,
        LightClientFinalityUpdate_8 as LightClientFinalityUpdate,
        LightClientOptimisticUpdate_7 as LightClientOptimisticUpdate,
        LightClientStore_7 as LightClientStore,
        PayloadAttributes_4 as PayloadAttributes,
        SSEPayloadAttributes_7 as SSEPayloadAttributes,
        BlockContents_3 as BlockContents,
        SignedBlockContents_3 as SignedBlockContents
    }
}

declare namespace ssz_8 {
    export {
        KZGProof_4 as KZGProof,
        Blob_4 as Blob,
        Metadata_5 as Metadata,
        Status_3 as Status,
        Cell,
        DataColumn,
        DataColumns,
        ExtendedMatrix,
        KzgCommitmentsInclusionProof,
        KZGProofs_3 as KZGProofs,
        ProposerLookahead,
        DataColumnSidecar,
        DataColumnSidecars,
        MatrixEntry,
        DataColumnsByRootIdentifier,
        DataColumnSidecarsByRangeRequest,
        BeaconBlocksByHeadRequest,
        BeaconBlock_13 as BeaconBlock,
        SignedBeaconBlock_13 as SignedBeaconBlock,
        BlobsBundle_3 as BlobsBundle,
        ExecutionPayloadAndBlobsBundle_3 as ExecutionPayloadAndBlobsBundle,
        BeaconState_13 as BeaconState,
        BlockContents_5 as BlockContents,
        SignedBlockContents_5 as SignedBlockContents
    }
}

declare namespace ssz_9 {
    export {
        Builder_2 as Builder,
        BuilderPendingWithdrawal,
        BuilderPendingPayment,
        PayloadTimelinessCommittee,
        PtcWindow,
        PayloadAttestationData,
        PayloadAttestation,
        PayloadAttestationMessage,
        IndexedPayloadAttestation,
        ProposerPreferences,
        SignedProposerPreferences,
        ExecutionPayloadBid,
        SignedExecutionPayloadBid,
        BlockAccessList,
        ExecutionPayload_9 as ExecutionPayload,
        ExecutionPayloadEnvelope,
        SignedExecutionPayloadEnvelope,
        BeaconBlockBody_13 as BeaconBlockBody,
        BeaconBlock_15 as BeaconBlock,
        SignedBeaconBlock_15 as SignedBeaconBlock,
        BeaconState_15 as BeaconState,
        DataColumnSidecar_3 as DataColumnSidecar,
        DataColumnSidecars_3 as DataColumnSidecars,
        ExecutionPayloadEnvelopesByRangeRequest,
        PayloadAttributes_5 as PayloadAttributes,
        SSEPayloadAttributes_9 as SSEPayloadAttributes
    }
}

declare type SszRequestData<P extends JsonRequestData> = Omit<P, "body"> & ("body" extends keyof P ? (P["body"] extends void ? {
    body?: never;
} : {
    body: Uint8Array;
}) : {
    body?: never;
});

declare type SszRequestMethods<E extends Endpoint> = {
    writeReqSsz: (p: E["args"]) => SszRequestData<E["request"]>;
    parseReqSsz: (r: SszRequestData<E["request"]>) => E["args"];
};

declare type SSZTypesByFork = {
    [F in keyof typeof typesByFork]: {
        [T in keyof (typeof typesByFork)[F]]: (typeof typesByFork)[F][T];
    };
};

declare type SSZTypesFor<F extends ForkName, K extends keyof SSZTypesByFork[F] | void = void> = K extends void ? {
    [K2 in keyof SSZTypesByFork[F]]: UnionSSZForksTypeOf<SSZTypesByFork[F][K2]>;
} : UnionSSZForksTypeOf<SSZTypesByFork[F][Exclude<K, void>]>;

declare namespace state {
    export {
        getDefinitions_3 as getDefinitions,
        StateId,
        StateArgs,
        ValidatorId,
        ValidatorStatus,
        RandaoResponseType,
        FinalityCheckpointsType,
        ValidatorResponseType,
        ValidatorIdentityType,
        EpochCommitteeResponseType,
        ValidatorBalanceType,
        EpochSyncCommitteeResponseType,
        ValidatorResponseListType,
        ValidatorIdentitiesType,
        EpochCommitteeResponseListType,
        ValidatorBalanceListType,
        RandaoResponse,
        FinalityCheckpoints,
        ValidatorResponse,
        EpochCommitteeResponse,
        ValidatorBalance,
        EpochSyncCommitteeResponse,
        ValidatorResponseList,
        ValidatorIdentities,
        EpochCommitteeResponseList,
        ValidatorBalanceList,
        Endpoints_5 as Endpoints
    }
}

declare type StateArgs = {
    /**
     * State identifier.
     * Can be one of: "head" (canonical head in node's view), "genesis", "finalized", "justified", \<slot\>, \<hex encoded stateRoot with 0x prefix\>.
     */
    stateId: StateId;
};

declare type StateCacheItem = {
    slot: Slot_2;
    root: RootHex;
    /** Total number of reads */
    reads: number;
    /** Unix timestamp (ms) of the last read */
    lastRead: number;
    checkpointState: boolean;
};

declare type StateId = RootHex | Slot_2 | "head" | "genesis" | "finalized" | "justified";

declare const Status: ContainerType<{
    forkDigest: ByteVectorType;
    finalizedRoot: ByteVectorType;
    finalizedEpoch: UintNumberType;
    headRoot: ByteVectorType;
    headSlot: UintNumberType;
}>;

declare type Status_2 = ValueOf<typeof ssz_2.Status>;

declare const Status_3: ContainerType<{
    forkDigest: ByteVectorType;
    finalizedRoot: ByteVectorType;
    finalizedEpoch: UintNumberType;
    headRoot: ByteVectorType;
    headSlot: UintNumberType;
    earliestAvailableSlot: UintNumberType;
}>;

declare type Status_4 = ValueOf<typeof ssz_8.Status>;

declare class StringType<T extends string = string> extends BasicType<T> {
    readonly typeName = "string";
    byteLength: number;
    fixedSize: number;
    minSize: number;
    maxSize: number;
    defaultValue(): T;
    value_serializeToBytes(): number;
    value_deserializeFromBytes(): T;
    tree_serializeToBytes(): number;
    tree_deserializeFromBytes(): never;
    tree_getFromNode(): T;
    tree_setToNode(): void;
    tree_getFromPackedNode(): T;
    tree_setToPackedNode(): void;
    fromJson(json: unknown): T;
    toJson(value: T): unknown;
}

/** @see CommitteeIndex */
declare const SubcommitteeIndex: UintNumberType;

declare function sumBits(bits: BitArray): number;

declare const SYNC_COMMITTEES_DEPTH = 4;

declare const SYNC_COMMITTEES_INDEX = 11;

declare const SyncAggregate: ContainerType<{
    syncCommitteeBits: BitVectorType;
    syncCommitteeSignature: ByteVectorType;
}>;

declare type SyncAggregate_2 = ValueOf<typeof ssz_3.SyncAggregate>;

declare const SyncAggregatorSelectionData: ContainerType<{
    slot: UintNumberType;
    subcommitteeIndex: UintNumberType;
}>;

declare type SyncAggregatorSelectionData_2 = ValueOf<typeof ssz_3.SyncAggregatorSelectionData>;

declare type SyncChainDebugState = {
    targetRoot: string | null;
    targetSlot: number | null;
    syncType: string;
    status: string;
    startEpoch: number;
    peers: number;
    batches: any[];
};

declare const SyncCommittee: ContainerType<{
    pubkeys: VectorCompositeType<ByteVectorType>;
    aggregatePubkey: ByteVectorType;
}>;

declare type SyncCommittee_2 = ValueOf<typeof ssz_3.SyncCommittee>;

declare const SyncCommitteeBits: BitVectorType;

declare const SyncCommitteeContribution: ContainerType<{
    slot: UintNumberType;
    beaconBlockRoot: ByteVectorType;
    subcommitteeIndex: UintNumberType;
    aggregationBits: BitVectorType;
    signature: ByteVectorType;
}>;

declare type SyncCommitteeContribution_2 = ValueOf<typeof ssz_3.SyncCommitteeContribution>;

export declare type SyncCommitteeFast = {
    pubkeys: PublicKey[];
    aggregatePubkey: PublicKey;
};

declare const SyncCommitteeMessage: ContainerType<{
    slot: UintNumberType;
    beaconBlockRoot: ByteVectorType;
    validatorIndex: UintNumberType;
    signature: ByteVectorType;
}>;

declare type SyncCommitteeMessage_2 = ValueOf<typeof ssz_3.SyncCommitteeMessage>;

declare type SyncCommitteeMessageList = ValueOf<typeof SyncCommitteeMessageListType>;

declare const SyncCommitteeMessageListType: ArrayType<Type<ValueOfFields<    {
slot: UintNumberType;
beaconBlockRoot: ByteVectorType;
validatorIndex: UintNumberType;
signature: ByteVectorType;
}>>, unknown, unknown>;

/**
 * Rewards info for sync committee participation. Every reward value is in Gwei.
 * Note: In the case that block proposer is present in `SyncCommitteeRewards`, the reward value only reflects rewards for
 * participating in sync committee. Please refer to `BlockRewards.syncAggregate` for rewards of proposer including sync committee
 * outputs into their block
 */
declare type SyncCommitteeRewards = ValueOf<typeof SyncCommitteeRewardsType>;

declare const SyncCommitteeRewardsType: ArrayType<Type<ValueOfFields<    {
validatorIndex: UintNumberType;
reward: UintNumberType;
}>>, unknown, unknown>;

declare type SyncCommitteeSelection = ValueOf<typeof SyncCommitteeSelectionType>;

declare type SyncCommitteeSelectionList = ValueOf<typeof SyncCommitteeSelectionListType>;

declare const SyncCommitteeSelectionListType: ArrayType<Type<ValueOfFields<    {
/** Index of the validator */
validatorIndex: UintNumberType;
/** The slot at which validator is assigned to produce a sync committee contribution */
slot: UintNumberType;
/** SubcommitteeIndex to which the validator is assigned */
subcommitteeIndex: UintNumberType;
/** The `slot_signature` calculated by the validator for the upcoming sync committee slot */
selectionProof: ByteVectorType;
}>>, unknown, unknown>;

/**
 * From https://github.com/ethereum/beacon-APIs/pull/224
 */
declare const SyncCommitteeSelectionType: ContainerType<{
    /** Index of the validator */
    validatorIndex: UintNumberType;
    /** The slot at which validator is assigned to produce a sync committee contribution */
    slot: UintNumberType;
    /** SubcommitteeIndex to which the validator is assigned */
    subcommitteeIndex: UintNumberType;
    /** The `slot_signature` calculated by the validator for the upcoming sync committee slot */
    selectionProof: ByteVectorType;
}>;

declare type SyncCommitteeSubscription = ValueOf<typeof SyncCommitteeSubscriptionType>;

declare type SyncCommitteeSubscriptionList = ValueOf<typeof SyncCommitteeSubscriptionListType>;

declare const SyncCommitteeSubscriptionListType: ArrayType<Type<ValueOfFields<    {
validatorIndex: UintNumberType;
syncCommitteeIndices: ArrayType<Type<number>, unknown, unknown>;
untilEpoch: UintNumberType;
}>>, unknown, unknown>;

/**
 * From https://github.com/ethereum/beacon-APIs/pull/136
 */
declare const SyncCommitteeSubscriptionType: ContainerType<{
    validatorIndex: UintNumberType;
    syncCommitteeIndices: ArrayType<Type<number>, unknown, unknown>;
    untilEpoch: UintNumberType;
}>;

declare type SyncDuty = ValueOf<typeof SyncDutyType>;

declare type SyncDutyList = ValueOf<typeof SyncDutyListType>;

declare const SyncDutyListType: ArrayType<Type<ValueOfFields<    {
pubkey: ByteVectorType;
/** Index of validator in validator registry. */
validatorIndex: UintNumberType;
/** The indices of the validator in the sync committee. */
validatorSyncCommitteeIndices: ArrayType<Type<number>, unknown, unknown>;
}>>, unknown, unknown>;

/**
 * From https://github.com/ethereum/beacon-APIs/pull/134
 */
declare const SyncDutyType: ContainerType<{
    pubkey: ByteVectorType;
    /** Index of validator in validator registry. */
    validatorIndex: UintNumberType;
    /** The indices of the validator in the sync committee. */
    validatorSyncCommitteeIndices: ArrayType<Type<number>, unknown, unknown>;
}>;

declare type SyncingStatus = ValueOf<typeof SyncingStatusType>;

declare const SyncingStatusType: ContainerType<{
    /** Head slot node is trying to reach */
    headSlot: UintNumberType;
    /** How many slots node needs to process to reach head. 0 if synced. */
    syncDistance: UintNumberType;
    /** Set to true if the node is syncing, false if the node is synced. */
    isSyncing: BooleanType;
    /** Set to true if the node is optimistically tracking head. */
    isOptimistic: BooleanType;
    /** Set to true if the connected el client is offline */
    elOffline: BooleanType;
}>;

/**
 * Use JS Number for performance, values must be limited to 2**52-1.
 * SyncPeriod is a time unit, so in all usages it's bounded by the clock, ensuring < 2**53-1
 */
declare const SyncPeriod: UintNumberType;

declare type SyncPeriod_2 = UintNum64_2;

declare type SyncSubnets = ValueOf<typeof ssz_3.SyncSubnets>;

declare const SyncSubnets_2: BitVectorType;

declare function timeUntilNextEpoch(config: Pick<ChainConfig, "SLOT_DURATION_MS">, genesisTime: number): number;

declare function toBlockHeader(block: ts_2.BeaconBlock): BeaconBlockHeader_2;

/**
 * Rewards info for actual attestations
 */
declare type TotalAttestationsReward = ValueOf<typeof TotalAttestationsRewardsType>;

declare const TotalAttestationsRewardsType: ContainerType<{
    /** Reward for head vote. Could be negative to indicate penalty */
    head: UintNumberType;
    /** Reward for target vote. Could be negative to indicate penalty */
    target: UintNumberType;
    /** Reward for source vote. Could be negative to indicate penalty */
    source: UintNumberType;
    /** Inclusion delay reward (phase0 only) */
    inclusionDelay: UintNumberType;
    /** Inactivity penalty. Should be a negative number to indicate penalty */
    inactivity: UintNumberType;
    validatorIndex: UintNumberType;
}>;

declare type Transaction = ValueOf<typeof ssz_4.Transaction>;

/**
 * ByteList[MAX_BYTES_PER_TRANSACTION]
 *
 * Spec v1.0.1
 */
declare const Transaction_2: ByteListType;

/**
 * Union[OpaqueTransaction]
 *
 * Spec v1.0.1
 */
declare const Transactions: ListCompositeType<ByteListType>;

declare type Transactions_2 = ValueOf<typeof ssz_4.Transactions>;

declare namespace transport {
    export {
        LightClientTransport,
        LightClientRestEvents,
        LightClientRestEmitter,
        LightClientRestTransport
    }
}
export { transport }

/**
 * Binary merkle tree
 *
 * Wrapper around immutable `Node` to support mutability.
 *
 * Mutability between a parent tree and subtree is achieved by maintaining a `hook` callback, which updates the parent when the subtree is updated.
 */
declare class Tree {
    private _rootNode;
    private hook?;
    constructor(node: Node_2, hook?: Hook);
    /**
     * The root hash of the tree
     */
    get root(): Uint8Array;
    /**
     * The root node of the tree
     */
    get rootNode(): Node_2;
    /**
     *
     * Setting the root node will trigger a call to the tree's `hook` if it exists.
     */
    set rootNode(newRootNode: Node_2);
    /**
     * Create a `Tree` from a `Proof` object
     */
    static createFromProof(proof: Proof): Tree;
    /**
     * Return a copy of the tree
     */
    clone(): Tree;
    /**
     * Return the subtree at the specified gindex.
     *
     * Note: The returned subtree will have a `hook` attached to the parent tree.
     * Updates to the subtree will result in updates to the parent.
     */
    getSubtree(index: Gindex | GindexBitstring): Tree;
    /**
     * Return the node at the specified gindex.
     */
    getNode(gindex: Gindex | GindexBitstring): Node_2;
    /**
     * Return the node at the specified depth and index.
     *
     * Supports index up to `Number.MAX_SAFE_INTEGER`.
     */
    getNodeAtDepth(depth: number, index: number): Node_2;
    /**
     * Return the hash at the specified gindex.
     */
    getRoot(index: Gindex | GindexBitstring): Uint8Array;
    /**
     * Set the node at at the specified gindex.
     */
    setNode(gindex: Gindex | GindexBitstring, n: Node_2): void;
    /**
     * Traverse to the node at the specified gindex,
     * then apply the function to get a new node and set the node at the specified gindex with the result.
     *
     * This is a convenient method to avoid traversing the tree 2 times to
     * get and set.
     */
    setNodeWithFn(gindex: Gindex | GindexBitstring, getNewNode: (node: Node_2) => Node_2): void;
    /**
     * Set the node at the specified depth and index.
     *
     * Supports index up to `Number.MAX_SAFE_INTEGER`.
     */
    setNodeAtDepth(depth: number, index: number, node: Node_2): void;
    /**
     * Set the hash at the specified gindex.
     *
     * Note: This will set a new `LeafNode` at the specified gindex.
     */
    setRoot(index: Gindex | GindexBitstring, root: Uint8Array): void;
    /**
     * Fast read-only iteration
     * In-order traversal of nodes at `depth`
     * starting from the `startIndex`-indexed node
     * iterating through `count` nodes
     *
     * Supports index up to `Number.MAX_SAFE_INTEGER`.
     */
    getNodesAtDepth(depth: number, startIndex: number, count: number): Node_2[];
    /**
     * Fast read-only iteration
     * In-order traversal of nodes at `depth`
     * starting from the `startIndex`-indexed node
     * iterating through `count` nodes
     *
     * Supports index up to `Number.MAX_SAFE_INTEGER`.
     */
    iterateNodesAtDepth(depth: number, startIndex: number, count: number): IterableIterator<Node_2>;
    /**
     * Return a merkle proof for the node at the specified gindex.
     */
    getSingleProof(index: Gindex): Uint8Array[];
    /**
     * Return a merkle proof for the proof input.
     *
     * This method can be used to create multiproofs.
     */
    getProof(input: ProofInput): Proof;
}

/**
 * A proof for multiple leaves in a tree.
 *
 * See https://github.com/protolambda/eth-merkle-trees/blob/master/tree_offsets.md
 */
declare interface TreeOffsetProof {
    type: ProofType.treeOffset;
    offsets: number[];
    leaves: Uint8Array[];
}

declare interface TreeOffsetProofInput {
    type: ProofType.treeOffset;
    gindices: Gindex[];
}

/**
 * A Tree View is a wrapper around a type and an SSZ Tree that contains:
 * - data merkleized
 * - a hook to its parent Tree to propagate changes upwards
 *
 * **View**
 * - Best for simple usage where performance is NOT important
 * - Applies changes immediately
 * - Has reference to parent tree
 * - Does NOT have caches for fast get / set ops
 */
declare abstract class TreeView<T extends CompositeType<unknown, unknown, unknown>> {
    /** Merkle tree root node */
    abstract readonly node: Node_2;
    /** SSZ type associated with this Tree View */
    abstract readonly type: T;
    /** Serialize view to binary data */
    serialize(): Uint8Array;
    /**
     * Merkleize view and compute its hashTreeRoot.
     *
     * See spec for definition of hashTreeRoot:
     * https://github.com/ethereum/consensus-specs/blob/v1.6.1/ssz/simple-serialize.md#merkleization
     */
    hashTreeRoot(): Uint8Array;
    /**
     * Create a Merkle multiproof on this view's data.
     * A `path` is an array of 'JSON' paths into the data
     * @example
     * ```ts
     * state.createProof([
     *   ["validators", 1234, "slashed"],
     *   ["genesisTime"]
     * ])
     * ```
     *
     * See spec for definition of merkle multiproofs:
     * https://github.com/ethereum/consensus-specs/blob/v1.6.1/ssz/merkle-proofs.md#merkle-multiproofs
     */
    createProof(paths: JsonPath[]): Proof;
    /**
     * Transform the view into a value, from the current node instance.
     * For ViewDU returns the value of the committed data, so call .commit() before if there are pending changes.
     */
    toValue(): ValueOf<T>;
    /** Return a new Tree View instance referencing the same internal `Node`. Drops its existing `Tree` hook if any */
    clone(): this;
}

/**
 * A Deferred Update Tree View (`ViewDU`) is a wrapper around a type and
 * a SSZ Node that contains:
 * - data merkleized
 * - some arbitrary caches to speed up data manipulation required by the type
 *
 * **ViewDU**
 * - Best for complex usage where performance is important
 * - Defers changes to when commit is called
 * - Does NOT have a reference to the parent ViewDU
 * - Has caches for fast get / set ops
 */
declare abstract class TreeViewDU<T extends CompositeType<unknown, unknown, unknown>> extends TreeView<T> {
    /**
     * Applies any deferred updates that may be pending in this ViewDU instance and updates its internal `Node`.
     * @param hcOffset The offset of the current node from root
     * @param hcByLevel The global HashComputationLevel array, this is output parameter
     * These are optional parameters that are used to compute hashTreeRoot() in batch if they are provided.
     */
    abstract commit(hcOffset?: number, hcByLevel?: HashComputationLevel[] | null): void;
    /**
     * Returns arbitrary data that is useful for this ViewDU instance to optimize data manipulation. This caches MUST
     * not include non-commited data. `this.cache` can be called at any time, both before and after calling `commit()`.
     */
    abstract readonly cache: unknown;
    /**
     * MUST drop any reference to mutable cache data. After `clearCache()`, if the dropped caches are mutated, no changes
     * should apply to this instance both before and after calling `commit()`.
     */
    protected abstract clearCache(): void;
    serializeToBytes(output: ByteViews, offset: number): number;
    /**
     * Merkleize view and compute its hashTreeRoot.
     * Commits any pending changes before computing the root.
     *
     * See spec for definition of hashTreeRoot:
     * https://github.com/ethereum/consensus-specs/blob/v1.6.1/ssz/simple-serialize.md#merkleization
     */
    hashTreeRoot(): Uint8Array;
    /**
     * The same to hashTreeRoot() but with batch hash computation.
     * Consumer can allocate and reuse a HashComputationGroup() if needed.
     */
    batchHashTreeRoot(hcGroup?: HashComputationGroup): Uint8Array;
    /**
     * Serialize view to binary data.
     * Commits any pending changes before computing the root.
     * This calls commit() which evict all pending HashComputations. Consider calling hashTreeRoot() before this
     */
    serialize(): Uint8Array;
    /**
     * Return a new ViewDU instance referencing the same internal `Node`.
     *
     * By default it will transfer the cache of this ViewDU to the new cloned instance. Set `dontTransferCache` to true
     * to NOT transfer the cache to the cloned instance.
     */
    clone(dontTransferCache?: boolean): this;
}

declare namespace ts {
    export {
        AttestationSubnets,
        BeaconBlockHeader_2 as BeaconBlockHeader,
        BeaconBlockHeaderBigint_2 as BeaconBlockHeaderBigint,
        SignedBeaconBlockHeader_2 as SignedBeaconBlockHeader,
        SignedBeaconBlockHeaderBigint_2 as SignedBeaconBlockHeaderBigint,
        Checkpoint_2 as Checkpoint,
        DepositMessage_2 as DepositMessage,
        DepositData_2 as DepositData,
        DepositEvent_2 as DepositEvent,
        Eth1Data_2 as Eth1Data,
        Eth1DataOrdered_2 as Eth1DataOrdered,
        Eth1Block_2 as Eth1Block,
        Fork_2 as Fork,
        ForkData_2 as ForkData,
        ENRForkID_2 as ENRForkID,
        HistoricalBatch_2 as HistoricalBatch,
        Validator_2 as Validator,
        Validators_2 as Validators,
        AttestationData_2 as AttestationData,
        AttestationDataBigint_2 as AttestationDataBigint,
        IndexedAttestation_2 as IndexedAttestation,
        IndexedAttestationBigint_2 as IndexedAttestationBigint,
        PendingAttestation_2 as PendingAttestation,
        SigningData_2 as SigningData,
        Attestation_2 as Attestation,
        AttesterSlashing_2 as AttesterSlashing,
        Deposit_2 as Deposit,
        ProposerSlashing_2 as ProposerSlashing,
        VoluntaryExit_2 as VoluntaryExit,
        SignedVoluntaryExit_2 as SignedVoluntaryExit,
        BeaconBlockBody_2 as BeaconBlockBody,
        BeaconBlock_2 as BeaconBlock,
        SignedBeaconBlock_2 as SignedBeaconBlock,
        BeaconState_2 as BeaconState,
        CommitteeAssignment_2 as CommitteeAssignment,
        AggregateAndProof_2 as AggregateAndProof,
        SignedAggregateAndProof_2 as SignedAggregateAndProof,
        Status_2 as Status,
        Goodbye_2 as Goodbye,
        Ping_2 as Ping,
        Metadata_2 as Metadata,
        BeaconBlocksByRangeRequest_2 as BeaconBlocksByRangeRequest,
        Genesis_2 as Genesis
    }
}

declare namespace ts_2 {
    export {
        SyncSubnets,
        Metadata_4 as Metadata,
        SyncCommittee_2 as SyncCommittee,
        SyncCommitteeMessage_2 as SyncCommitteeMessage,
        SyncCommitteeContribution_2 as SyncCommitteeContribution,
        ContributionAndProof_2 as ContributionAndProof,
        SignedContributionAndProof_2 as SignedContributionAndProof,
        SyncAggregatorSelectionData_2 as SyncAggregatorSelectionData,
        SyncAggregate_2 as SyncAggregate,
        BeaconBlockBody_4 as BeaconBlockBody,
        BeaconBlock_4 as BeaconBlock,
        SignedBeaconBlock_4 as SignedBeaconBlock,
        BeaconState_4 as BeaconState,
        LightClientHeader_2 as LightClientHeader,
        LightClientBootstrap_2 as LightClientBootstrap,
        LightClientUpdate_2 as LightClientUpdate,
        LightClientFinalityUpdate_3 as LightClientFinalityUpdate,
        LightClientOptimisticUpdate_2 as LightClientOptimisticUpdate,
        LightClientStore_2 as LightClientStore,
        LightClientUpdatesByRange_2 as LightClientUpdatesByRange
    }
}

declare namespace ts_3 {
    export {
        Transaction,
        Transactions_2 as Transactions,
        ExecutionPayload_2 as ExecutionPayload,
        ExecutionPayloadHeader_2 as ExecutionPayloadHeader,
        BeaconBlockBody_6 as BeaconBlockBody,
        BeaconBlock_6 as BeaconBlock,
        SignedBeaconBlock_6 as SignedBeaconBlock,
        BeaconState_6 as BeaconState,
        PowBlock_2 as PowBlock,
        BlindedBeaconBlockBody_2 as BlindedBeaconBlockBody,
        BlindedBeaconBlock_2 as BlindedBeaconBlock,
        SignedBlindedBeaconBlock_2 as SignedBlindedBeaconBlock,
        ValidatorRegistrationV1_2 as ValidatorRegistrationV1,
        SignedValidatorRegistrationV1_2 as SignedValidatorRegistrationV1,
        BuilderBid_2 as BuilderBid,
        SignedBuilderBid_2 as SignedBuilderBid,
        SSEPayloadAttributes_2 as SSEPayloadAttributes,
        FullOrBlindedExecutionPayload
    }
}

declare namespace ts_4 {
    export {
        Withdrawal,
        Withdrawals_2 as Withdrawals,
        BLSToExecutionChange_2 as BLSToExecutionChange,
        BLSToExecutionChanges_2 as BLSToExecutionChanges,
        SignedBLSToExecutionChange_2 as SignedBLSToExecutionChange,
        ExecutionPayload_4 as ExecutionPayload,
        ExecutionPayloadHeader_4 as ExecutionPayloadHeader,
        BeaconBlockBody_8 as BeaconBlockBody,
        BeaconBlock_8 as BeaconBlock,
        SignedBeaconBlock_8 as SignedBeaconBlock,
        BeaconState_8 as BeaconState,
        BlindedBeaconBlockBody_4 as BlindedBeaconBlockBody,
        BlindedBeaconBlock_4 as BlindedBeaconBlock,
        SignedBlindedBeaconBlock_4 as SignedBlindedBeaconBlock,
        FullOrBlindedExecutionPayload_2 as FullOrBlindedExecutionPayload,
        BuilderBid_4 as BuilderBid,
        SignedBuilderBid_4 as SignedBuilderBid,
        SSEPayloadAttributes_4 as SSEPayloadAttributes,
        LightClientHeader_4 as LightClientHeader,
        LightClientBootstrap_4 as LightClientBootstrap,
        LightClientUpdate_4 as LightClientUpdate,
        LightClientFinalityUpdate_5 as LightClientFinalityUpdate,
        LightClientOptimisticUpdate_4 as LightClientOptimisticUpdate,
        LightClientStore_4 as LightClientStore,
        HistoricalSummaries_2 as HistoricalSummaries
    }
}

declare namespace ts_5 {
    export {
        KZGProof,
        KZGCommitment_2 as KZGCommitment,
        Blob_3 as Blob,
        Blobs_2 as Blobs,
        BlobSidecar_2 as BlobSidecar,
        BlobSidecars_2 as BlobSidecars,
        ExecutionPayloadAndBlobsBundle_2 as ExecutionPayloadAndBlobsBundle,
        BlobsBundle_2 as BlobsBundle,
        KzgCommitmentInclusionProof_2 as KzgCommitmentInclusionProof,
        BlobKzgCommitments_2 as BlobKzgCommitments,
        KZGProofs_2 as KZGProofs,
        BLSFieldElement_2 as BLSFieldElement,
        BlobIdentifier_2 as BlobIdentifier,
        BlobSidecarsByRangeRequest_2 as BlobSidecarsByRangeRequest,
        ExecutionPayload_6 as ExecutionPayload,
        ExecutionPayloadHeader_6 as ExecutionPayloadHeader,
        BeaconBlockBody_10 as BeaconBlockBody,
        BeaconBlock_10 as BeaconBlock,
        SignedBeaconBlock_10 as SignedBeaconBlock,
        BeaconState_10 as BeaconState,
        BlindedBeaconBlockBody_6 as BlindedBeaconBlockBody,
        BlindedBeaconBlock_6 as BlindedBeaconBlock,
        SignedBlindedBeaconBlock_6 as SignedBlindedBeaconBlock,
        FullOrBlindedExecutionPayload_3 as FullOrBlindedExecutionPayload,
        BuilderBid_6 as BuilderBid,
        SignedBuilderBid_6 as SignedBuilderBid,
        SSEPayloadAttributes_6 as SSEPayloadAttributes,
        LightClientHeader_6 as LightClientHeader,
        LightClientBootstrap_6 as LightClientBootstrap,
        LightClientUpdate_6 as LightClientUpdate,
        LightClientFinalityUpdate_7 as LightClientFinalityUpdate,
        LightClientOptimisticUpdate_6 as LightClientOptimisticUpdate,
        LightClientStore_6 as LightClientStore,
        ProducedBlobSidecars,
        BlockContents_2 as BlockContents,
        SignedBlockContents_2 as SignedBlockContents,
        BlobAndProof
    }
}

declare namespace ts_6 {
    export {
        Attestation_3 as Attestation,
        SingleAttestation_3 as SingleAttestation,
        IndexedAttestation_4 as IndexedAttestation,
        IndexedAttestationBigint_4 as IndexedAttestationBigint,
        AttesterSlashing_4 as AttesterSlashing,
        AggregateAndProof_4 as AggregateAndProof,
        SignedAggregateAndProof_4 as SignedAggregateAndProof,
        DepositRequest_2 as DepositRequest,
        DepositRequests_2 as DepositRequests,
        WithdrawalRequest_2 as WithdrawalRequest,
        WithdrawalRequests_2 as WithdrawalRequests,
        ConsolidationRequest_2 as ConsolidationRequest,
        ConsolidationRequests_2 as ConsolidationRequests,
        ExecutionPayload_8 as ExecutionPayload,
        ExecutionPayloadHeader_8 as ExecutionPayloadHeader,
        ExecutionRequests_2 as ExecutionRequests,
        BeaconBlockBody_12 as BeaconBlockBody,
        BeaconBlock_12 as BeaconBlock,
        SignedBeaconBlock_12 as SignedBeaconBlock,
        BeaconState_12 as BeaconState,
        BlindedBeaconBlockBody_8 as BlindedBeaconBlockBody,
        BlindedBeaconBlock_8 as BlindedBeaconBlock,
        SignedBlindedBeaconBlock_8 as SignedBlindedBeaconBlock,
        BuilderBid_8 as BuilderBid,
        SignedBuilderBid_8 as SignedBuilderBid,
        SSEPayloadAttributes_8 as SSEPayloadAttributes,
        LightClientBootstrap_8 as LightClientBootstrap,
        LightClientUpdate_8 as LightClientUpdate,
        LightClientFinalityUpdate_9 as LightClientFinalityUpdate,
        LightClientOptimisticUpdate_8 as LightClientOptimisticUpdate,
        LightClientStore_8 as LightClientStore,
        PendingDeposit_2 as PendingDeposit,
        PendingDeposits_2 as PendingDeposits,
        PendingPartialWithdrawal_2 as PendingPartialWithdrawal,
        PendingPartialWithdrawals_2 as PendingPartialWithdrawals,
        PendingConsolidation_2 as PendingConsolidation,
        PendingConsolidations_2 as PendingConsolidations,
        BlockContents_4 as BlockContents,
        SignedBlockContents_4 as SignedBlockContents
    }
}

declare namespace ts_7 {
    export {
        KZGProof_3 as KZGProof,
        Blob_5 as Blob,
        Metadata_6 as Metadata,
        Status_4 as Status,
        Cell_2 as Cell,
        DataColumn_2 as DataColumn,
        ExtendedMatrix_2 as ExtendedMatrix,
        KzgCommitmentsInclusionProof_2 as KzgCommitmentsInclusionProof,
        DataColumnSidecar_2 as DataColumnSidecar,
        DataColumnSidecars_2 as DataColumnSidecars,
        MatrixEntry_2 as MatrixEntry,
        ProposerLookahead_2 as ProposerLookahead,
        DataColumnsByRootIdentifier_2 as DataColumnsByRootIdentifier,
        DataColumnSidecarsByRangeRequest_2 as DataColumnSidecarsByRangeRequest,
        BeaconBlocksByHeadRequest_2 as BeaconBlocksByHeadRequest,
        BeaconBlock_14 as BeaconBlock,
        SignedBeaconBlock_14 as SignedBeaconBlock,
        BeaconState_14 as BeaconState,
        BlockContents_6 as BlockContents,
        SignedBlockContents_6 as SignedBlockContents,
        ExecutionPayloadAndBlobsBundle_4 as ExecutionPayloadAndBlobsBundle,
        BlobsBundle_4 as BlobsBundle,
        BlobAndProofV2
    }
}

declare namespace ts_8 {
    export {
        Builder,
        BuilderPendingWithdrawal_2 as BuilderPendingWithdrawal,
        BuilderPendingPayment_2 as BuilderPendingPayment,
        PayloadTimelinessCommittee_2 as PayloadTimelinessCommittee,
        PtcWindow_2 as PtcWindow,
        PayloadAttestationData_2 as PayloadAttestationData,
        PayloadAttestation_2 as PayloadAttestation,
        PayloadAttestationMessage_2 as PayloadAttestationMessage,
        IndexedPayloadAttestation_2 as IndexedPayloadAttestation,
        ProposerPreferences_2 as ProposerPreferences,
        SignedProposerPreferences_2 as SignedProposerPreferences,
        ExecutionPayload_10 as ExecutionPayload,
        ExecutionPayloadBid_2 as ExecutionPayloadBid,
        SignedExecutionPayloadBid_2 as SignedExecutionPayloadBid,
        BlockAccessList_2 as BlockAccessList,
        ExecutionPayloadEnvelope_2 as ExecutionPayloadEnvelope,
        SignedExecutionPayloadEnvelope_2 as SignedExecutionPayloadEnvelope,
        BeaconBlockBody_14 as BeaconBlockBody,
        BeaconBlock_16 as BeaconBlock,
        SignedBeaconBlock_16 as SignedBeaconBlock,
        BeaconState_16 as BeaconState,
        DataColumnSidecar_4 as DataColumnSidecar,
        DataColumnSidecars_4 as DataColumnSidecars,
        ExecutionPayloadEnvelopesByRangeRequest_2 as ExecutionPayloadEnvelopesByRangeRequest,
        PayloadAttributes_6 as PayloadAttributes,
        SSEPayloadAttributes_10 as SSEPayloadAttributes
    }
}

/**
 * An SSZ type provides the following operations:
 * - Serialization from/to bytes to either a value or a tree
 * - Merkelization to compute the hashTreeRoot of both a value and a tree
 * - Proof creation from trees
 * - Create a View and a ViewDU instance from a tree
 * - Manipulate views
 */
declare abstract class Type<V> {
    /**
     * If `true`, the type is basic.
     *
     * If `false`, the type is composite
     */
    abstract readonly isBasic: boolean;
    /** Tree depth to chunks or LeafNodes */
    abstract readonly depth: number;
    /** Maximum count of LeafNode chunks this type can have when merkleized */
    abstract readonly maxChunkCount: number;
    /**
     * The number of bytes of the serialized value.
     *
     * If `fixedSize === null`, the type has a variable serialized bytelength.
     */
    abstract readonly fixedSize: number | null;
    /** Minimum possible size of this type. Equals `this.fixedSize` if fixed size */
    abstract readonly minSize: number;
    /** Maximum possible size of this type. Equals `this.fixedSize` if fixed size */
    abstract readonly maxSize: number;
    /**
     * Human readable name
     *
     * @example
     * "List(Uint,4)"
     * "BeaconState"
     */
    abstract readonly typeName: string;
    /** INTERNAL METHOD: Return serialized size of a value */
    abstract value_serializedSize(value: V): number;
    /** INTERNAL METHOD: Serialize value to existing output ArrayBuffer views */
    abstract value_serializeToBytes(output: ByteViews, offset: number, value: V): number;
    /** INTERNAL METHOD: Deserialize value from a section of ArrayBuffer views */
    abstract value_deserializeFromBytes(data: ByteViews, start: number, end: number, reuseBytes?: boolean): V;
    /** INTERNAL METHOD: Return serialized size of a tree */
    abstract tree_serializedSize(node: Node_2): number;
    /** INTERNAL METHOD: Serialize tree to existing output ArrayBuffer views  */
    abstract tree_serializeToBytes(output: ByteViews, offset: number, node: Node_2): number;
    /** INTERNAL METHOD: Deserialize tree from a section of ArrayBuffer views */
    abstract tree_deserializeFromBytes(data: ByteViews, start: number, end: number): Node_2;
    /** INTERNAL METHOD: Merkleize value to tree */
    value_toTree(value: V): Node_2;
    /** INTERNAL METHOD: Un-merkleize tree to value */
    tree_toValue(node: Node_2): V;
    /** New instance of a recursive zero'ed value of this type */
    abstract defaultValue(): V;
    /** Serialize a value to binary data */
    serialize(value: V): Uint8Array;
    /** Deserialize binary data to value */
    deserialize(uint8Array: Uint8Array, opts?: {
        reuseBytes?: boolean;
    }): V;
    /**
     * Merkleize value and compute its hashTreeRoot.
     *
     * See spec for definition of hashTreeRoot:
     * https://github.com/ethereum/consensus-specs/blob/v1.6.1/ssz/simple-serialize.md#merkleization
     */
    abstract hashTreeRoot(value: V): Uint8Array;
    /**
     * Same to hashTreeRoot() but here we write result to output.
     */
    abstract hashTreeRootInto(value: V, output: Uint8Array, offset: number): void;
    /** Parse JSON representation of a type to value */
    abstract fromJson(json: unknown): V;
    /** Convert value into its JSON representation */
    abstract toJson(value: V): unknown;
    /**
     * Returns a recursive clone of all mutable Types of a value, such that it can be safely mutated.
     *
     * Note: Immutable types and subtypes, such as `ByteVector`, return the original value.
     */
    abstract clone(value: V): V;
    /**
     * Returns true if values `a` and `b` are deeply equal by value
     */
    abstract equals(a: V, b: V): boolean;
}

declare type TypeJson<T> = {
    toJson: (data: T) => unknown;
    fromJson: (data: unknown) => T;
};

declare type TypesByFork = {
    [ForkName.phase0]: {
        BeaconBlockHeader: ts.BeaconBlockHeader;
        SignedBeaconBlockHeader: ts.SignedBeaconBlockHeader;
        BeaconBlock: ts.BeaconBlock;
        BeaconBlockBody: ts.BeaconBlockBody;
        BeaconState: ts.BeaconState;
        SignedBeaconBlock: ts.SignedBeaconBlock;
        Metadata: ts.Metadata;
        Status: ts.Status;
        SingleAttestation: ts.Attestation;
        Attestation: ts.Attestation;
        IndexedAttestation: ts.IndexedAttestation;
        IndexedAttestationBigint: ts.IndexedAttestationBigint;
        AttesterSlashing: ts.AttesterSlashing;
        AggregateAndProof: ts.AggregateAndProof;
        SignedAggregateAndProof: ts.SignedAggregateAndProof;
        BlockContents: {
            block: ts.BeaconBlock;
        };
        SignedBlockContents: {
            signedBlock: ts.SignedBeaconBlock;
        };
    };
    [ForkName.altair]: {
        BeaconBlockHeader: ts.BeaconBlockHeader;
        SignedBeaconBlockHeader: ts.SignedBeaconBlockHeader;
        BeaconBlock: ts_2.BeaconBlock;
        BeaconBlockBody: ts_2.BeaconBlockBody;
        BeaconState: ts_2.BeaconState;
        SignedBeaconBlock: ts_2.SignedBeaconBlock;
        Metadata: ts_2.Metadata;
        Status: ts.Status;
        LightClientHeader: ts_2.LightClientHeader;
        LightClientBootstrap: ts_2.LightClientBootstrap;
        LightClientUpdate: ts_2.LightClientUpdate;
        LightClientFinalityUpdate: ts_2.LightClientFinalityUpdate;
        LightClientOptimisticUpdate: ts_2.LightClientOptimisticUpdate;
        LightClientStore: ts_2.LightClientStore;
        SyncCommittee: ts_2.SyncCommittee;
        SyncAggregate: ts_2.SyncAggregate;
        SingleAttestation: ts.Attestation;
        Attestation: ts.Attestation;
        IndexedAttestation: ts.IndexedAttestation;
        IndexedAttestationBigint: ts.IndexedAttestationBigint;
        AttesterSlashing: ts.AttesterSlashing;
        AggregateAndProof: ts.AggregateAndProof;
        SignedAggregateAndProof: ts.SignedAggregateAndProof;
        BlockContents: {
            block: ts_2.BeaconBlock;
        };
        SignedBlockContents: {
            signedBlock: ts_2.SignedBeaconBlock;
        };
    };
    [ForkName.bellatrix]: {
        BeaconBlockHeader: ts.BeaconBlockHeader;
        SignedBeaconBlockHeader: ts.SignedBeaconBlockHeader;
        BeaconBlock: ts_3.BeaconBlock;
        BeaconBlockBody: ts_3.BeaconBlockBody;
        BeaconState: ts_3.BeaconState;
        SignedBeaconBlock: ts_3.SignedBeaconBlock;
        Metadata: ts_2.Metadata;
        Status: ts.Status;
        LightClientHeader: ts_2.LightClientHeader;
        LightClientBootstrap: ts_2.LightClientBootstrap;
        LightClientUpdate: ts_2.LightClientUpdate;
        LightClientFinalityUpdate: ts_2.LightClientFinalityUpdate;
        LightClientOptimisticUpdate: ts_2.LightClientOptimisticUpdate;
        LightClientStore: ts_2.LightClientStore;
        BlindedBeaconBlock: ts_3.BlindedBeaconBlock;
        BlindedBeaconBlockBody: ts_3.BlindedBeaconBlockBody;
        SignedBlindedBeaconBlock: ts_3.SignedBlindedBeaconBlock;
        ExecutionPayload: ts_3.ExecutionPayload;
        ExecutionPayloadHeader: ts_3.ExecutionPayloadHeader;
        BuilderBid: ts_3.BuilderBid;
        SignedBuilderBid: ts_3.SignedBuilderBid;
        SSEPayloadAttributes: ts_3.SSEPayloadAttributes;
        SyncCommittee: ts_2.SyncCommittee;
        SyncAggregate: ts_2.SyncAggregate;
        SingleAttestation: ts.Attestation;
        Attestation: ts.Attestation;
        IndexedAttestation: ts.IndexedAttestation;
        IndexedAttestationBigint: ts.IndexedAttestationBigint;
        AttesterSlashing: ts.AttesterSlashing;
        AggregateAndProof: ts.AggregateAndProof;
        SignedAggregateAndProof: ts.SignedAggregateAndProof;
        BlockContents: {
            block: ts_3.BeaconBlock;
        };
        SignedBlockContents: {
            signedBlock: ts_3.SignedBeaconBlock;
        };
    };
    [ForkName.capella]: {
        BeaconBlockHeader: ts.BeaconBlockHeader;
        SignedBeaconBlockHeader: ts.SignedBeaconBlockHeader;
        BeaconBlock: ts_4.BeaconBlock;
        BeaconBlockBody: ts_4.BeaconBlockBody;
        BeaconState: ts_4.BeaconState;
        SignedBeaconBlock: ts_4.SignedBeaconBlock;
        Metadata: ts_2.Metadata;
        Status: ts.Status;
        LightClientHeader: ts_4.LightClientHeader;
        LightClientBootstrap: ts_4.LightClientBootstrap;
        LightClientUpdate: ts_4.LightClientUpdate;
        LightClientFinalityUpdate: ts_4.LightClientFinalityUpdate;
        LightClientOptimisticUpdate: ts_4.LightClientOptimisticUpdate;
        LightClientStore: ts_4.LightClientStore;
        BlindedBeaconBlock: ts_4.BlindedBeaconBlock;
        BlindedBeaconBlockBody: ts_4.BlindedBeaconBlockBody;
        SignedBlindedBeaconBlock: ts_4.SignedBlindedBeaconBlock;
        ExecutionPayload: ts_4.ExecutionPayload;
        ExecutionPayloadHeader: ts_4.ExecutionPayloadHeader;
        BuilderBid: ts_4.BuilderBid;
        SignedBuilderBid: ts_4.SignedBuilderBid;
        SSEPayloadAttributes: ts_4.SSEPayloadAttributes;
        SyncCommittee: ts_2.SyncCommittee;
        SyncAggregate: ts_2.SyncAggregate;
        SingleAttestation: ts.Attestation;
        Attestation: ts.Attestation;
        IndexedAttestation: ts.IndexedAttestation;
        IndexedAttestationBigint: ts.IndexedAttestationBigint;
        AttesterSlashing: ts.AttesterSlashing;
        AggregateAndProof: ts.AggregateAndProof;
        SignedAggregateAndProof: ts.SignedAggregateAndProof;
        BlockContents: {
            block: ts_4.BeaconBlock;
        };
        SignedBlockContents: {
            signedBlock: ts_4.SignedBeaconBlock;
        };
    };
    [ForkName.deneb]: {
        BeaconBlockHeader: ts.BeaconBlockHeader;
        SignedBeaconBlockHeader: ts.SignedBeaconBlockHeader;
        BeaconBlock: ts_5.BeaconBlock;
        BeaconBlockBody: ts_5.BeaconBlockBody;
        BeaconState: ts_5.BeaconState;
        SignedBeaconBlock: ts_5.SignedBeaconBlock;
        Metadata: ts_2.Metadata;
        Status: ts.Status;
        LightClientHeader: ts_5.LightClientHeader;
        LightClientBootstrap: ts_5.LightClientBootstrap;
        LightClientUpdate: ts_5.LightClientUpdate;
        LightClientFinalityUpdate: ts_5.LightClientFinalityUpdate;
        LightClientOptimisticUpdate: ts_5.LightClientOptimisticUpdate;
        LightClientStore: ts_5.LightClientStore;
        BlindedBeaconBlock: ts_5.BlindedBeaconBlock;
        BlindedBeaconBlockBody: ts_5.BlindedBeaconBlockBody;
        SignedBlindedBeaconBlock: ts_5.SignedBlindedBeaconBlock;
        ExecutionPayload: ts_5.ExecutionPayload;
        ExecutionPayloadHeader: ts_5.ExecutionPayloadHeader;
        BuilderBid: ts_5.BuilderBid;
        SignedBuilderBid: ts_5.SignedBuilderBid;
        SSEPayloadAttributes: ts_5.SSEPayloadAttributes;
        BlockContents: ts_5.BlockContents;
        SignedBlockContents: ts_5.SignedBlockContents;
        ExecutionPayloadAndBlobsBundle: ts_5.ExecutionPayloadAndBlobsBundle;
        BlobsBundle: ts_5.BlobsBundle;
        SyncCommittee: ts_2.SyncCommittee;
        SyncAggregate: ts_2.SyncAggregate;
        SingleAttestation: ts.Attestation;
        Attestation: ts.Attestation;
        IndexedAttestation: ts.IndexedAttestation;
        IndexedAttestationBigint: ts.IndexedAttestationBigint;
        AttesterSlashing: ts.AttesterSlashing;
        AggregateAndProof: ts.AggregateAndProof;
        SignedAggregateAndProof: ts.SignedAggregateAndProof;
    };
    [ForkName.electra]: {
        BeaconBlockHeader: ts.BeaconBlockHeader;
        SignedBeaconBlockHeader: ts.SignedBeaconBlockHeader;
        BeaconBlock: ts_6.BeaconBlock;
        BeaconBlockBody: ts_6.BeaconBlockBody;
        BeaconState: ts_6.BeaconState;
        SignedBeaconBlock: ts_6.SignedBeaconBlock;
        Metadata: ts_2.Metadata;
        Status: ts.Status;
        LightClientHeader: ts_5.LightClientHeader;
        LightClientBootstrap: ts_6.LightClientBootstrap;
        LightClientUpdate: ts_6.LightClientUpdate;
        LightClientFinalityUpdate: ts_6.LightClientFinalityUpdate;
        LightClientOptimisticUpdate: ts_6.LightClientOptimisticUpdate;
        LightClientStore: ts_6.LightClientStore;
        BlindedBeaconBlock: ts_6.BlindedBeaconBlock;
        BlindedBeaconBlockBody: ts_6.BlindedBeaconBlockBody;
        SignedBlindedBeaconBlock: ts_6.SignedBlindedBeaconBlock;
        ExecutionPayload: ts_5.ExecutionPayload;
        ExecutionPayloadHeader: ts_5.ExecutionPayloadHeader;
        BuilderBid: ts_6.BuilderBid;
        SignedBuilderBid: ts_6.SignedBuilderBid;
        SSEPayloadAttributes: ts_6.SSEPayloadAttributes;
        BlockContents: ts_6.BlockContents;
        SignedBlockContents: ts_6.SignedBlockContents;
        ExecutionPayloadAndBlobsBundle: ts_5.ExecutionPayloadAndBlobsBundle;
        BlobsBundle: ts_5.BlobsBundle;
        SyncCommittee: ts_2.SyncCommittee;
        SyncAggregate: ts_2.SyncAggregate;
        SingleAttestation: ts_6.SingleAttestation;
        Attestation: ts_6.Attestation;
        IndexedAttestation: ts_6.IndexedAttestation;
        IndexedAttestationBigint: ts_6.IndexedAttestationBigint;
        AttesterSlashing: ts_6.AttesterSlashing;
        AggregateAndProof: ts_6.AggregateAndProof;
        SignedAggregateAndProof: ts_6.SignedAggregateAndProof;
        ExecutionRequests: ts_6.ExecutionRequests;
    };
    [ForkName.fulu]: {
        BeaconBlockHeader: ts.BeaconBlockHeader;
        SignedBeaconBlockHeader: ts.SignedBeaconBlockHeader;
        BeaconBlock: ts_6.BeaconBlock;
        BeaconBlockBody: ts_6.BeaconBlockBody;
        BeaconState: ts_7.BeaconState;
        SignedBeaconBlock: ts_6.SignedBeaconBlock;
        Metadata: ts_7.Metadata;
        Status: ts_7.Status;
        LightClientHeader: ts_5.LightClientHeader;
        LightClientBootstrap: ts_6.LightClientBootstrap;
        LightClientUpdate: ts_6.LightClientUpdate;
        LightClientFinalityUpdate: ts_6.LightClientFinalityUpdate;
        LightClientOptimisticUpdate: ts_6.LightClientOptimisticUpdate;
        LightClientStore: ts_6.LightClientStore;
        BlindedBeaconBlock: ts_6.BlindedBeaconBlock;
        BlindedBeaconBlockBody: ts_6.BlindedBeaconBlockBody;
        SignedBlindedBeaconBlock: ts_6.SignedBlindedBeaconBlock;
        ExecutionPayload: ts_5.ExecutionPayload;
        ExecutionPayloadHeader: ts_5.ExecutionPayloadHeader;
        BuilderBid: ts_6.BuilderBid;
        SignedBuilderBid: ts_6.SignedBuilderBid;
        SSEPayloadAttributes: ts_6.SSEPayloadAttributes;
        BlockContents: ts_7.BlockContents;
        SignedBlockContents: ts_7.SignedBlockContents;
        ExecutionPayloadAndBlobsBundle: ts_7.ExecutionPayloadAndBlobsBundle;
        BlobsBundle: ts_7.BlobsBundle;
        SyncCommittee: ts_2.SyncCommittee;
        SyncAggregate: ts_2.SyncAggregate;
        SingleAttestation: ts_6.SingleAttestation;
        Attestation: ts_6.Attestation;
        IndexedAttestation: ts_6.IndexedAttestation;
        IndexedAttestationBigint: ts_6.IndexedAttestationBigint;
        AttesterSlashing: ts_6.AttesterSlashing;
        AggregateAndProof: ts_6.AggregateAndProof;
        SignedAggregateAndProof: ts_6.SignedAggregateAndProof;
        ExecutionRequests: ts_6.ExecutionRequests;
        DataColumnSidecar: ts_7.DataColumnSidecar;
        DataColumnSidecars: ts_7.DataColumnSidecars;
    };
    [ForkName.gloas]: {
        BeaconBlockHeader: ts.BeaconBlockHeader;
        SignedBeaconBlockHeader: ts.SignedBeaconBlockHeader;
        BeaconBlock: ts_8.BeaconBlock;
        BeaconBlockBody: ts_8.BeaconBlockBody;
        BeaconState: ts_8.BeaconState;
        SignedBeaconBlock: ts_8.SignedBeaconBlock;
        Metadata: ts_7.Metadata;
        Status: ts_7.Status;
        LightClientHeader: ts_5.LightClientHeader;
        LightClientBootstrap: ts_6.LightClientBootstrap;
        LightClientUpdate: ts_6.LightClientUpdate;
        LightClientFinalityUpdate: ts_6.LightClientFinalityUpdate;
        LightClientOptimisticUpdate: ts_6.LightClientOptimisticUpdate;
        LightClientStore: ts_6.LightClientStore;
        BlindedBeaconBlock: ts_6.BlindedBeaconBlock;
        BlindedBeaconBlockBody: ts_6.BlindedBeaconBlockBody;
        SignedBlindedBeaconBlock: ts_6.SignedBlindedBeaconBlock;
        ExecutionPayload: ts_8.ExecutionPayload;
        ExecutionPayloadHeader: ts_5.ExecutionPayloadHeader;
        BuilderBid: ts_6.BuilderBid;
        SignedBuilderBid: ts_6.SignedBuilderBid;
        SSEPayloadAttributes: ts_8.SSEPayloadAttributes;
        BlockContents: ts_7.BlockContents;
        SignedBlockContents: ts_7.SignedBlockContents;
        ExecutionPayloadAndBlobsBundle: ts_7.ExecutionPayloadAndBlobsBundle;
        BlobsBundle: ts_7.BlobsBundle;
        SyncCommittee: ts_2.SyncCommittee;
        SyncAggregate: ts_2.SyncAggregate;
        SingleAttestation: ts_6.SingleAttestation;
        Attestation: ts_6.Attestation;
        IndexedAttestation: ts_6.IndexedAttestation;
        IndexedAttestationBigint: ts_6.IndexedAttestationBigint;
        AttesterSlashing: ts_6.AttesterSlashing;
        AggregateAndProof: ts_6.AggregateAndProof;
        SignedAggregateAndProof: ts_6.SignedAggregateAndProof;
        ExecutionRequests: ts_6.ExecutionRequests;
        ExecutionPayloadBid: ts_8.ExecutionPayloadBid;
        DataColumnSidecar: ts_8.DataColumnSidecar;
        DataColumnSidecars: ts_8.DataColumnSidecars;
    };
};

/**
 * Index the ssz types that differ by fork
 * A record of AllForksSSZTypes indexed by fork
 */
declare const typesByFork: {
    phase0: {
        AttestationSubnets: BitVectorType;
        BeaconBlockHeader: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        BeaconBlockHeaderBigint: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        SignedBeaconBlockHeader: ContainerType<{
            message: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        SignedBeaconBlockHeaderBigint: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        Checkpoint: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
        }>;
        CheckpointBigint: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
        }>;
        CommitteeBits: BitListType;
        CommitteeIndices: ListBasicType<UintNumberType>;
        DepositMessage: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
        }>;
        DepositData: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
        }>;
        DepositDataRootList: ListCompositeType<ByteVectorType>;
        DepositEvent: ContainerType<{
            depositData: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
            }>;
            blockNumber: UintNumberType;
            index: UintNumberType;
        }>;
        Eth1Data: ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
        }>;
        Eth1DataVotes: ListCompositeType<ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
        }>>;
        Eth1DataOrdered: ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
            blockNumber: UintNumberType;
        }>;
        Eth1Block: ContainerType<{
            timestamp: UintNumberType;
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
        }>;
        Fork: ContainerType<{
            previousVersion: ByteVectorType;
            currentVersion: ByteVectorType;
            epoch: UintNumberType;
        }>;
        ForkData: ContainerType<{
            currentVersion: ByteVectorType;
            genesisValidatorsRoot: ByteVectorType;
        }>;
        ENRForkID: ContainerType<{
            forkDigest: ByteVectorType;
            nextForkVersion: ByteVectorType;
            nextForkEpoch: UintNumberType;
        }>;
        HistoricalBlockRoots: VectorCompositeType<ByteVectorType>;
        HistoricalStateRoots: VectorCompositeType<ByteVectorType>;
        HistoricalBatch: ContainerType<{
            blockRoots: VectorCompositeType<ByteVectorType>;
            stateRoots: VectorCompositeType<ByteVectorType>;
        }>;
        HistoricalBatchRoots: ContainerType<{
            blockRoots: ByteVectorType;
            stateRoots: ByteVectorType;
        }>;
        Validator: ValidatorNodeStructType;
        Validators: ListCompositeType<ValidatorNodeStructType>;
        Balances: ListUintNum64Type;
        RandaoMixes: VectorCompositeType<ByteVectorType>;
        Slashings: VectorBasicType<UintNumberType>;
        JustificationBits: BitVectorType;
        AttestationData: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
        }>;
        AttestationDataBigint: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
            }>;
        }>;
        IndexedAttestation: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        IndexedAttestationBigint: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        PendingAttestation: ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            inclusionDelay: UintNumberType;
            proposerIndex: UintNumberType;
        }>;
        SigningData: ContainerType<{
            objectRoot: ByteVectorType;
            domain: ByteVectorType;
        }>;
        Attestation: ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        SingleAttestation: ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        AttesterSlashing: ContainerType<{
            attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
        }>;
        Deposit: ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
            }>;
        }>;
        ProposerSlashing: ContainerType<{
            signedHeader1: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
        }>;
        VoluntaryExit: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
        }>;
        SignedVoluntaryExit: ContainerType<{
            message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
        }>;
        BeaconBlockBody: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
            signedHeader1: ContainerType<{
            message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
            message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
            }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
            attestation1: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
            message: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
            }>>;
        }>;
        BeaconBlock: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            body: ContainerType<{
                randaoReveal: ByteVectorType;
                eth1Data: ContainerType<{
                    depositRoot: ByteVectorType;
                    depositCount: UintNumberType;
                    blockHash: ByteVectorType;
                }>;
                graffiti: ByteVectorType;
                proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
                }>;
                }>>;
                attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>;
                }>>;
                attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>>;
                deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                }>;
                }>>;
                voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
                }>>;
            }>;
        }>;
        SignedBeaconBlock: ContainerType<{
            message: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                body: ContainerType<{
                    randaoReveal: ByteVectorType;
                    eth1Data: ContainerType<{
                        depositRoot: ByteVectorType;
                        depositCount: UintNumberType;
                        blockHash: ByteVectorType;
                    }>;
                    graffiti: ByteVectorType;
                    proposerSlashings: ListCompositeType<ContainerType<{
                    signedHeader1: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    signedHeader2: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attesterSlashings: ListCompositeType<ContainerType<{
                    attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attestations: ListCompositeType<ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    deposits: ListCompositeType<ContainerType<{
                    proof: VectorCompositeType<ByteVectorType>;
                    data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    voluntaryExits: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        EpochAttestations: ListCompositeType<ContainerType<{
        aggregationBits: BitListType;
        data: ContainerType<{
        slot: UintNumberType;
        index: UintNumberType;
        beaconBlockRoot: ByteVectorType;
        source: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
        }>;
        target: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
        }>;
        }>;
        inclusionDelay: UintNumberType;
        proposerIndex: UintNumberType;
        }>>;
        BeaconState: ContainerType<{
            genesisTime: UintNumberType;
            genesisValidatorsRoot: ByteVectorType;
            slot: UintNumberType;
            fork: ContainerType<{
                previousVersion: ByteVectorType;
                currentVersion: ByteVectorType;
                epoch: UintNumberType;
            }>;
            latestBlockHeader: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            blockRoots: VectorCompositeType<ByteVectorType>;
            stateRoots: VectorCompositeType<ByteVectorType>;
            historicalRoots: ListCompositeType<ByteVectorType>;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            eth1DataVotes: ListCompositeType<ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
            }>>;
            eth1DepositIndex: UintNumberType;
            validators: ListCompositeType<ValidatorNodeStructType>;
            balances: ListUintNum64Type;
            randaoMixes: VectorCompositeType<ByteVectorType>;
            slashings: VectorBasicType<UintNumberType>;
            previousEpochAttestations: ListCompositeType<ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            }>;
            inclusionDelay: UintNumberType;
            proposerIndex: UintNumberType;
            }>>;
            currentEpochAttestations: ListCompositeType<ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            }>;
            inclusionDelay: UintNumberType;
            proposerIndex: UintNumberType;
            }>>;
            justificationBits: BitVectorType;
            previousJustifiedCheckpoint: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            currentJustifiedCheckpoint: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            finalizedCheckpoint: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
        }>;
        CommitteeAssignment: ContainerType<{
            validators: ListBasicType<UintNumberType>;
            committeeIndex: UintNumberType;
            slot: UintNumberType;
        }>;
        AggregateAndProof: ContainerType<{
            aggregatorIndex: UintNumberType;
            aggregate: ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            selectionProof: ByteVectorType;
        }>;
        SignedAggregateAndProof: ContainerType<{
            message: ContainerType<{
                aggregatorIndex: UintNumberType;
                aggregate: ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                        slot: UintNumberType;
                        index: UintNumberType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintNumberType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintNumberType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
                selectionProof: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        Status: ContainerType<{
            forkDigest: ByteVectorType;
            finalizedRoot: ByteVectorType;
            finalizedEpoch: UintNumberType;
            headRoot: ByteVectorType;
            headSlot: UintNumberType;
        }>;
        Goodbye: UintBigintType;
        Ping: UintBigintType;
        Metadata: ContainerType<{
            seqNumber: UintBigintType;
            attnets: BitVectorType;
        }>;
        BeaconBlocksByRangeRequest: ContainerType<{
            startSlot: UintNumberType;
            count: UintNumberType;
            step: UintNumberType;
        }>;
        Genesis: ContainerType<{
            genesisValidatorsRoot: ByteVectorType;
            genesisTime: UintNumberType;
            genesisForkVersion: ByteVectorType;
        }>;
    };
    altair: {
        AttestationSubnets: BitVectorType;
        BeaconBlockHeader: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        BeaconBlockHeaderBigint: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        SignedBeaconBlockHeader: ContainerType<{
            message: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        SignedBeaconBlockHeaderBigint: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        Checkpoint: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
        }>;
        CheckpointBigint: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
        }>;
        CommitteeBits: BitListType;
        CommitteeIndices: ListBasicType<UintNumberType>;
        DepositMessage: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
        }>;
        DepositData: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
        }>;
        DepositDataRootList: ListCompositeType<ByteVectorType>;
        DepositEvent: ContainerType<{
            depositData: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
            }>;
            blockNumber: UintNumberType;
            index: UintNumberType;
        }>;
        Eth1Data: ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
        }>;
        Eth1DataVotes: ListCompositeType<ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
        }>>;
        Eth1DataOrdered: ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
            blockNumber: UintNumberType;
        }>;
        Eth1Block: ContainerType<{
            timestamp: UintNumberType;
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
        }>;
        Fork: ContainerType<{
            previousVersion: ByteVectorType;
            currentVersion: ByteVectorType;
            epoch: UintNumberType;
        }>;
        ForkData: ContainerType<{
            currentVersion: ByteVectorType;
            genesisValidatorsRoot: ByteVectorType;
        }>;
        ENRForkID: ContainerType<{
            forkDigest: ByteVectorType;
            nextForkVersion: ByteVectorType;
            nextForkEpoch: UintNumberType;
        }>;
        HistoricalBlockRoots: VectorCompositeType<ByteVectorType>;
        HistoricalStateRoots: VectorCompositeType<ByteVectorType>;
        HistoricalBatch: ContainerType<{
            blockRoots: VectorCompositeType<ByteVectorType>;
            stateRoots: VectorCompositeType<ByteVectorType>;
        }>;
        HistoricalBatchRoots: ContainerType<{
            blockRoots: ByteVectorType;
            stateRoots: ByteVectorType;
        }>;
        Validator: ValidatorNodeStructType;
        Validators: ListCompositeType<ValidatorNodeStructType>;
        Balances: ListUintNum64Type;
        RandaoMixes: VectorCompositeType<ByteVectorType>;
        Slashings: VectorBasicType<UintNumberType>;
        JustificationBits: BitVectorType;
        AttestationData: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
        }>;
        AttestationDataBigint: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
            }>;
        }>;
        IndexedAttestation: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        IndexedAttestationBigint: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        PendingAttestation: ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            inclusionDelay: UintNumberType;
            proposerIndex: UintNumberType;
        }>;
        SigningData: ContainerType<{
            objectRoot: ByteVectorType;
            domain: ByteVectorType;
        }>;
        Attestation: ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        SingleAttestation: ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        AttesterSlashing: ContainerType<{
            attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
        }>;
        Deposit: ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
            }>;
        }>;
        ProposerSlashing: ContainerType<{
            signedHeader1: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
        }>;
        VoluntaryExit: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
        }>;
        SignedVoluntaryExit: ContainerType<{
            message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
        }>;
        EpochAttestations: ListCompositeType<ContainerType<{
        aggregationBits: BitListType;
        data: ContainerType<{
        slot: UintNumberType;
        index: UintNumberType;
        beaconBlockRoot: ByteVectorType;
        source: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
        }>;
        target: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
        }>;
        }>;
        inclusionDelay: UintNumberType;
        proposerIndex: UintNumberType;
        }>>;
        CommitteeAssignment: ContainerType<{
            validators: ListBasicType<UintNumberType>;
            committeeIndex: UintNumberType;
            slot: UintNumberType;
        }>;
        AggregateAndProof: ContainerType<{
            aggregatorIndex: UintNumberType;
            aggregate: ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            selectionProof: ByteVectorType;
        }>;
        SignedAggregateAndProof: ContainerType<{
            message: ContainerType<{
                aggregatorIndex: UintNumberType;
                aggregate: ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                        slot: UintNumberType;
                        index: UintNumberType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintNumberType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintNumberType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
                selectionProof: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        Status: ContainerType<{
            forkDigest: ByteVectorType;
            finalizedRoot: ByteVectorType;
            finalizedEpoch: UintNumberType;
            headRoot: ByteVectorType;
            headSlot: UintNumberType;
        }>;
        Goodbye: UintBigintType;
        Ping: UintBigintType;
        BeaconBlocksByRangeRequest: ContainerType<{
            startSlot: UintNumberType;
            count: UintNumberType;
            step: UintNumberType;
        }>;
        Genesis: ContainerType<{
            genesisValidatorsRoot: ByteVectorType;
            genesisTime: UintNumberType;
            genesisForkVersion: ByteVectorType;
        }>;
        SyncSubnets: BitVectorType;
        FinalityBranch: VectorCompositeType<ByteVectorType>;
        CurrentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
        NextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
        Metadata: ContainerType<{
            seqNumber: UintBigintType;
            attnets: BitVectorType;
            syncnets: BitVectorType;
        }>;
        SyncCommittee: ContainerType<{
            pubkeys: VectorCompositeType<ByteVectorType>;
            aggregatePubkey: ByteVectorType;
        }>;
        SyncCommitteeMessage: ContainerType<{
            slot: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            validatorIndex: UintNumberType;
            signature: ByteVectorType;
        }>;
        SyncCommitteeContribution: ContainerType<{
            slot: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            subcommitteeIndex: UintNumberType;
            aggregationBits: BitVectorType;
            signature: ByteVectorType;
        }>;
        ContributionAndProof: ContainerType<{
            aggregatorIndex: UintNumberType;
            contribution: ContainerType<{
                slot: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                subcommitteeIndex: UintNumberType;
                aggregationBits: BitVectorType;
                signature: ByteVectorType;
            }>;
            selectionProof: ByteVectorType;
        }>;
        SignedContributionAndProof: ContainerType<{
            message: ContainerType<{
                aggregatorIndex: UintNumberType;
                contribution: ContainerType<{
                    slot: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    subcommitteeIndex: UintNumberType;
                    aggregationBits: BitVectorType;
                    signature: ByteVectorType;
                }>;
                selectionProof: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        SyncAggregatorSelectionData: ContainerType<{
            slot: UintNumberType;
            subcommitteeIndex: UintNumberType;
        }>;
        SyncCommitteeBits: BitVectorType;
        SyncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
        }>;
        BeaconBlockBody: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
            signedHeader1: ContainerType<{
            message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
            message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
            }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
            attestation1: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
            message: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
            }>>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
        }>;
        BeaconBlock: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            body: ContainerType<{
                randaoReveal: ByteVectorType;
                eth1Data: ContainerType<{
                    depositRoot: ByteVectorType;
                    depositCount: UintNumberType;
                    blockHash: ByteVectorType;
                }>;
                graffiti: ByteVectorType;
                proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
                }>;
                }>>;
                attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>;
                }>>;
                attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>>;
                deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                }>;
                }>>;
                voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
                }>>;
                syncAggregate: ContainerType<{
                    syncCommitteeBits: BitVectorType;
                    syncCommitteeSignature: ByteVectorType;
                }>;
            }>;
        }>;
        SignedBeaconBlock: ContainerType<{
            message: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                body: ContainerType<{
                    randaoReveal: ByteVectorType;
                    eth1Data: ContainerType<{
                        depositRoot: ByteVectorType;
                        depositCount: UintNumberType;
                        blockHash: ByteVectorType;
                    }>;
                    graffiti: ByteVectorType;
                    proposerSlashings: ListCompositeType<ContainerType<{
                    signedHeader1: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    signedHeader2: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attesterSlashings: ListCompositeType<ContainerType<{
                    attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attestations: ListCompositeType<ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    deposits: ListCompositeType<ContainerType<{
                    proof: VectorCompositeType<ByteVectorType>;
                    data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    voluntaryExits: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    syncAggregate: ContainerType<{
                        syncCommitteeBits: BitVectorType;
                        syncCommitteeSignature: ByteVectorType;
                    }>;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        EpochParticipation: ListBasicType<UintNumberType>;
        InactivityScores: ListBasicType<UintNumberType>;
        BeaconState: ContainerType<{
            genesisTime: UintNumberType;
            genesisValidatorsRoot: ByteVectorType;
            slot: UintNumberType;
            fork: ContainerType<{
                previousVersion: ByteVectorType;
                currentVersion: ByteVectorType;
                epoch: UintNumberType;
            }>;
            latestBlockHeader: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            blockRoots: VectorCompositeType<ByteVectorType>;
            stateRoots: VectorCompositeType<ByteVectorType>;
            historicalRoots: ListCompositeType<ByteVectorType>;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            eth1DataVotes: ListCompositeType<ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
            }>>;
            eth1DepositIndex: UintNumberType;
            validators: ListCompositeType<ValidatorNodeStructType>;
            balances: ListUintNum64Type;
            randaoMixes: VectorCompositeType<ByteVectorType>;
            slashings: VectorBasicType<UintNumberType>;
            previousEpochParticipation: ListBasicType<UintNumberType>;
            currentEpochParticipation: ListBasicType<UintNumberType>;
            justificationBits: BitVectorType;
            previousJustifiedCheckpoint: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            currentJustifiedCheckpoint: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            finalizedCheckpoint: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            inactivityScores: ListBasicType<UintNumberType>;
            currentSyncCommittee: ContainerType<{
                pubkeys: VectorCompositeType<ByteVectorType>;
                aggregatePubkey: ByteVectorType;
            }>;
            nextSyncCommittee: ContainerType<{
                pubkeys: VectorCompositeType<ByteVectorType>;
                aggregatePubkey: ByteVectorType;
            }>;
        }>;
        LightClientHeader: ContainerType<{
            beacon: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
        }>;
        LightClientBootstrap: ContainerType<{
            header: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
            }>;
            currentSyncCommittee: ContainerType<{
                pubkeys: VectorCompositeType<ByteVectorType>;
                aggregatePubkey: ByteVectorType;
            }>;
            currentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
        }>;
        LightClientUpdate: ContainerType<{
            attestedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
            }>;
            nextSyncCommittee: ContainerType<{
                pubkeys: VectorCompositeType<ByteVectorType>;
                aggregatePubkey: ByteVectorType;
            }>;
            nextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
            finalizedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
            }>;
            finalityBranch: VectorCompositeType<ByteVectorType>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            signatureSlot: UintNumberType;
        }>;
        LightClientFinalityUpdate: ContainerType<{
            attestedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
            }>;
            finalizedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
            }>;
            finalityBranch: VectorCompositeType<ByteVectorType>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            signatureSlot: UintNumberType;
        }>;
        LightClientOptimisticUpdate: ContainerType<{
            attestedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
            }>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            signatureSlot: UintNumberType;
        }>;
        LightClientUpdatesByRange: ContainerType<{
            startPeriod: UintNumberType;
            count: UintNumberType;
        }>;
        LightClientStore: ContainerType<{
            snapshot: ContainerType<{
                header: ContainerType<{
                    beacon: ContainerType<{
                        slot: UintNumberType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                }>;
                currentSyncCommittee: ContainerType<{
                    pubkeys: VectorCompositeType<ByteVectorType>;
                    aggregatePubkey: ByteVectorType;
                }>;
                currentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
            }>;
            validUpdates: ListCompositeType<ContainerType<{
            attestedHeader: ContainerType<{
            beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            }>;
            nextSyncCommittee: ContainerType<{
            pubkeys: VectorCompositeType<ByteVectorType>;
            aggregatePubkey: ByteVectorType;
            }>;
            nextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
            finalizedHeader: ContainerType<{
            beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            }>;
            finalityBranch: VectorCompositeType<ByteVectorType>;
            syncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
            }>;
            signatureSlot: UintNumberType;
            }>>;
        }>;
    };
    bellatrix: {
        AttestationSubnets: BitVectorType;
        BeaconBlockHeader: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        BeaconBlockHeaderBigint: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        SignedBeaconBlockHeader: ContainerType<{
            message: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        SignedBeaconBlockHeaderBigint: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        Checkpoint: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
        }>;
        CheckpointBigint: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
        }>;
        CommitteeBits: BitListType;
        CommitteeIndices: ListBasicType<UintNumberType>;
        DepositMessage: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
        }>;
        DepositData: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
        }>;
        DepositDataRootList: ListCompositeType<ByteVectorType>;
        DepositEvent: ContainerType<{
            depositData: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
            }>;
            blockNumber: UintNumberType;
            index: UintNumberType;
        }>;
        Eth1Data: ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
        }>;
        Eth1DataVotes: ListCompositeType<ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
        }>>;
        Eth1DataOrdered: ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
            blockNumber: UintNumberType;
        }>;
        Eth1Block: ContainerType<{
            timestamp: UintNumberType;
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
        }>;
        Fork: ContainerType<{
            previousVersion: ByteVectorType;
            currentVersion: ByteVectorType;
            epoch: UintNumberType;
        }>;
        ForkData: ContainerType<{
            currentVersion: ByteVectorType;
            genesisValidatorsRoot: ByteVectorType;
        }>;
        ENRForkID: ContainerType<{
            forkDigest: ByteVectorType;
            nextForkVersion: ByteVectorType;
            nextForkEpoch: UintNumberType;
        }>;
        HistoricalBlockRoots: VectorCompositeType<ByteVectorType>;
        HistoricalStateRoots: VectorCompositeType<ByteVectorType>;
        HistoricalBatch: ContainerType<{
            blockRoots: VectorCompositeType<ByteVectorType>;
            stateRoots: VectorCompositeType<ByteVectorType>;
        }>;
        HistoricalBatchRoots: ContainerType<{
            blockRoots: ByteVectorType;
            stateRoots: ByteVectorType;
        }>;
        Validator: ValidatorNodeStructType;
        Validators: ListCompositeType<ValidatorNodeStructType>;
        Balances: ListUintNum64Type;
        RandaoMixes: VectorCompositeType<ByteVectorType>;
        Slashings: VectorBasicType<UintNumberType>;
        JustificationBits: BitVectorType;
        AttestationData: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
        }>;
        AttestationDataBigint: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
            }>;
        }>;
        IndexedAttestation: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        IndexedAttestationBigint: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        PendingAttestation: ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            inclusionDelay: UintNumberType;
            proposerIndex: UintNumberType;
        }>;
        SigningData: ContainerType<{
            objectRoot: ByteVectorType;
            domain: ByteVectorType;
        }>;
        Attestation: ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        SingleAttestation: ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        AttesterSlashing: ContainerType<{
            attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
        }>;
        Deposit: ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
            }>;
        }>;
        ProposerSlashing: ContainerType<{
            signedHeader1: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
        }>;
        VoluntaryExit: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
        }>;
        SignedVoluntaryExit: ContainerType<{
            message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
        }>;
        EpochAttestations: ListCompositeType<ContainerType<{
        aggregationBits: BitListType;
        data: ContainerType<{
        slot: UintNumberType;
        index: UintNumberType;
        beaconBlockRoot: ByteVectorType;
        source: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
        }>;
        target: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
        }>;
        }>;
        inclusionDelay: UintNumberType;
        proposerIndex: UintNumberType;
        }>>;
        CommitteeAssignment: ContainerType<{
            validators: ListBasicType<UintNumberType>;
            committeeIndex: UintNumberType;
            slot: UintNumberType;
        }>;
        AggregateAndProof: ContainerType<{
            aggregatorIndex: UintNumberType;
            aggregate: ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            selectionProof: ByteVectorType;
        }>;
        SignedAggregateAndProof: ContainerType<{
            message: ContainerType<{
                aggregatorIndex: UintNumberType;
                aggregate: ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                        slot: UintNumberType;
                        index: UintNumberType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintNumberType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintNumberType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
                selectionProof: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        Status: ContainerType<{
            forkDigest: ByteVectorType;
            finalizedRoot: ByteVectorType;
            finalizedEpoch: UintNumberType;
            headRoot: ByteVectorType;
            headSlot: UintNumberType;
        }>;
        Goodbye: UintBigintType;
        Ping: UintBigintType;
        BeaconBlocksByRangeRequest: ContainerType<{
            startSlot: UintNumberType;
            count: UintNumberType;
            step: UintNumberType;
        }>;
        Genesis: ContainerType<{
            genesisValidatorsRoot: ByteVectorType;
            genesisTime: UintNumberType;
            genesisForkVersion: ByteVectorType;
        }>;
        SyncSubnets: BitVectorType;
        FinalityBranch: VectorCompositeType<ByteVectorType>;
        CurrentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
        NextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
        Metadata: ContainerType<{
            seqNumber: UintBigintType;
            attnets: BitVectorType;
            syncnets: BitVectorType;
        }>;
        SyncCommittee: ContainerType<{
            pubkeys: VectorCompositeType<ByteVectorType>;
            aggregatePubkey: ByteVectorType;
        }>;
        SyncCommitteeMessage: ContainerType<{
            slot: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            validatorIndex: UintNumberType;
            signature: ByteVectorType;
        }>;
        SyncCommitteeContribution: ContainerType<{
            slot: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            subcommitteeIndex: UintNumberType;
            aggregationBits: BitVectorType;
            signature: ByteVectorType;
        }>;
        ContributionAndProof: ContainerType<{
            aggregatorIndex: UintNumberType;
            contribution: ContainerType<{
                slot: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                subcommitteeIndex: UintNumberType;
                aggregationBits: BitVectorType;
                signature: ByteVectorType;
            }>;
            selectionProof: ByteVectorType;
        }>;
        SignedContributionAndProof: ContainerType<{
            message: ContainerType<{
                aggregatorIndex: UintNumberType;
                contribution: ContainerType<{
                    slot: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    subcommitteeIndex: UintNumberType;
                    aggregationBits: BitVectorType;
                    signature: ByteVectorType;
                }>;
                selectionProof: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        SyncAggregatorSelectionData: ContainerType<{
            slot: UintNumberType;
            subcommitteeIndex: UintNumberType;
        }>;
        SyncCommitteeBits: BitVectorType;
        SyncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
        }>;
        EpochParticipation: ListBasicType<UintNumberType>;
        InactivityScores: ListBasicType<UintNumberType>;
        LightClientHeader: ContainerType<{
            beacon: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
        }>;
        LightClientBootstrap: ContainerType<{
            header: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
            }>;
            currentSyncCommittee: ContainerType<{
                pubkeys: VectorCompositeType<ByteVectorType>;
                aggregatePubkey: ByteVectorType;
            }>;
            currentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
        }>;
        LightClientUpdate: ContainerType<{
            attestedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
            }>;
            nextSyncCommittee: ContainerType<{
                pubkeys: VectorCompositeType<ByteVectorType>;
                aggregatePubkey: ByteVectorType;
            }>;
            nextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
            finalizedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
            }>;
            finalityBranch: VectorCompositeType<ByteVectorType>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            signatureSlot: UintNumberType;
        }>;
        LightClientFinalityUpdate: ContainerType<{
            attestedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
            }>;
            finalizedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
            }>;
            finalityBranch: VectorCompositeType<ByteVectorType>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            signatureSlot: UintNumberType;
        }>;
        LightClientOptimisticUpdate: ContainerType<{
            attestedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
            }>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            signatureSlot: UintNumberType;
        }>;
        LightClientUpdatesByRange: ContainerType<{
            startPeriod: UintNumberType;
            count: UintNumberType;
        }>;
        LightClientStore: ContainerType<{
            snapshot: ContainerType<{
                header: ContainerType<{
                    beacon: ContainerType<{
                        slot: UintNumberType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                }>;
                currentSyncCommittee: ContainerType<{
                    pubkeys: VectorCompositeType<ByteVectorType>;
                    aggregatePubkey: ByteVectorType;
                }>;
                currentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
            }>;
            validUpdates: ListCompositeType<ContainerType<{
            attestedHeader: ContainerType<{
            beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            }>;
            nextSyncCommittee: ContainerType<{
            pubkeys: VectorCompositeType<ByteVectorType>;
            aggregatePubkey: ByteVectorType;
            }>;
            nextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
            finalizedHeader: ContainerType<{
            beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            }>;
            finalityBranch: VectorCompositeType<ByteVectorType>;
            syncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
            }>;
            signatureSlot: UintNumberType;
            }>>;
        }>;
        Transaction: ByteListType;
        Transactions: ListCompositeType<ByteListType>;
        CommonExecutionPayloadType: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
        }>;
        ExecutionPayload: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactions: ListCompositeType<ByteListType>;
        }>;
        ExecutionPayloadHeader: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
        }>;
        BeaconBlockBody: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
            signedHeader1: ContainerType<{
            message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
            message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
            }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
            attestation1: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
            message: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
            }>>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            executionPayload: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactions: ListCompositeType<ByteListType>;
            }>;
        }>;
        BeaconBlock: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            body: ContainerType<{
                randaoReveal: ByteVectorType;
                eth1Data: ContainerType<{
                    depositRoot: ByteVectorType;
                    depositCount: UintNumberType;
                    blockHash: ByteVectorType;
                }>;
                graffiti: ByteVectorType;
                proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
                }>;
                }>>;
                attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>;
                }>>;
                attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>>;
                deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                }>;
                }>>;
                voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
                }>>;
                syncAggregate: ContainerType<{
                    syncCommitteeBits: BitVectorType;
                    syncCommitteeSignature: ByteVectorType;
                }>;
                executionPayload: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactions: ListCompositeType<ByteListType>;
                }>;
            }>;
        }>;
        SignedBeaconBlock: ContainerType<{
            message: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                body: ContainerType<{
                    randaoReveal: ByteVectorType;
                    eth1Data: ContainerType<{
                        depositRoot: ByteVectorType;
                        depositCount: UintNumberType;
                        blockHash: ByteVectorType;
                    }>;
                    graffiti: ByteVectorType;
                    proposerSlashings: ListCompositeType<ContainerType<{
                    signedHeader1: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    signedHeader2: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attesterSlashings: ListCompositeType<ContainerType<{
                    attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attestations: ListCompositeType<ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    deposits: ListCompositeType<ContainerType<{
                    proof: VectorCompositeType<ByteVectorType>;
                    data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    voluntaryExits: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    syncAggregate: ContainerType<{
                        syncCommitteeBits: BitVectorType;
                        syncCommitteeSignature: ByteVectorType;
                    }>;
                    executionPayload: ContainerType<{
                        parentHash: ByteVectorType;
                        feeRecipient: ExecutionAddressType;
                        stateRoot: ByteVectorType;
                        receiptsRoot: ByteVectorType;
                        logsBloom: ByteVectorType;
                        prevRandao: ByteVectorType;
                        blockNumber: UintNumberType;
                        gasLimit: UintNumberType;
                        gasUsed: UintNumberType;
                        timestamp: UintNumberType;
                        extraData: ByteListType;
                        baseFeePerGas: UintBigintType;
                        blockHash: ByteVectorType;
                        transactions: ListCompositeType<ByteListType>;
                    }>;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        PowBlock: ContainerType<{
            blockHash: ByteVectorType;
            parentHash: ByteVectorType;
            totalDifficulty: UintBigintType;
        }>;
        BeaconState: ContainerType<{
            genesisTime: UintNumberType;
            genesisValidatorsRoot: ByteVectorType;
            slot: UintNumberType;
            fork: ContainerType<{
                previousVersion: ByteVectorType;
                currentVersion: ByteVectorType;
                epoch: UintNumberType;
            }>;
            latestBlockHeader: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            blockRoots: VectorCompositeType<ByteVectorType>;
            stateRoots: VectorCompositeType<ByteVectorType>;
            historicalRoots: ListCompositeType<ByteVectorType>;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            eth1DataVotes: ListCompositeType<ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
            }>>;
            eth1DepositIndex: UintNumberType;
            validators: ListCompositeType<ValidatorNodeStructType>;
            balances: ListUintNum64Type;
            randaoMixes: VectorCompositeType<ByteVectorType>;
            slashings: VectorBasicType<UintNumberType>;
            previousEpochParticipation: ListBasicType<UintNumberType>;
            currentEpochParticipation: ListBasicType<UintNumberType>;
            justificationBits: BitVectorType;
            previousJustifiedCheckpoint: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            currentJustifiedCheckpoint: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            finalizedCheckpoint: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            inactivityScores: ListBasicType<UintNumberType>;
            currentSyncCommittee: ContainerType<{
                pubkeys: VectorCompositeType<ByteVectorType>;
                aggregatePubkey: ByteVectorType;
            }>;
            nextSyncCommittee: ContainerType<{
                pubkeys: VectorCompositeType<ByteVectorType>;
                aggregatePubkey: ByteVectorType;
            }>;
            latestExecutionPayloadHeader: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
            }>;
        }>;
        BlindedBeaconBlockBody: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
            signedHeader1: ContainerType<{
            message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
            message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
            }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
            attestation1: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
            message: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
            }>>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            executionPayloadHeader: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
            }>;
        }>;
        BlindedBeaconBlock: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            body: ContainerType<{
                randaoReveal: ByteVectorType;
                eth1Data: ContainerType<{
                    depositRoot: ByteVectorType;
                    depositCount: UintNumberType;
                    blockHash: ByteVectorType;
                }>;
                graffiti: ByteVectorType;
                proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
                }>;
                }>>;
                attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>;
                }>>;
                attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>>;
                deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                }>;
                }>>;
                voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
                }>>;
                syncAggregate: ContainerType<{
                    syncCommitteeBits: BitVectorType;
                    syncCommitteeSignature: ByteVectorType;
                }>;
                executionPayloadHeader: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                }>;
            }>;
        }>;
        SignedBlindedBeaconBlock: ContainerType<{
            message: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                body: ContainerType<{
                    randaoReveal: ByteVectorType;
                    eth1Data: ContainerType<{
                        depositRoot: ByteVectorType;
                        depositCount: UintNumberType;
                        blockHash: ByteVectorType;
                    }>;
                    graffiti: ByteVectorType;
                    proposerSlashings: ListCompositeType<ContainerType<{
                    signedHeader1: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    signedHeader2: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attesterSlashings: ListCompositeType<ContainerType<{
                    attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attestations: ListCompositeType<ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    deposits: ListCompositeType<ContainerType<{
                    proof: VectorCompositeType<ByteVectorType>;
                    data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    voluntaryExits: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    syncAggregate: ContainerType<{
                        syncCommitteeBits: BitVectorType;
                        syncCommitteeSignature: ByteVectorType;
                    }>;
                    executionPayloadHeader: ContainerType<{
                        parentHash: ByteVectorType;
                        feeRecipient: ExecutionAddressType;
                        stateRoot: ByteVectorType;
                        receiptsRoot: ByteVectorType;
                        logsBloom: ByteVectorType;
                        prevRandao: ByteVectorType;
                        blockNumber: UintNumberType;
                        gasLimit: UintNumberType;
                        gasUsed: UintNumberType;
                        timestamp: UintNumberType;
                        extraData: ByteListType;
                        baseFeePerGas: UintBigintType;
                        blockHash: ByteVectorType;
                        transactionsRoot: ByteVectorType;
                    }>;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        ValidatorRegistrationV1: ContainerType<{
            feeRecipient: ExecutionAddressType;
            gasLimit: UintNumberType;
            timestamp: UintNumberType;
            pubkey: ByteVectorType;
        }>;
        SignedValidatorRegistrationV1: ContainerType<{
            message: ContainerType<{
                feeRecipient: ExecutionAddressType;
                gasLimit: UintNumberType;
                timestamp: UintNumberType;
                pubkey: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        BuilderBid: ContainerType<{
            header: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
            }>;
            value: UintBigintType;
            pubkey: ByteVectorType;
        }>;
        SignedBuilderBid: ContainerType<{
            message: ContainerType<{
                header: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                }>;
                value: UintBigintType;
                pubkey: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        PayloadAttributes: ContainerType<{
            timestamp: UintNumberType;
            prevRandao: ByteVectorType;
            suggestedFeeRecipient: StringType<string>;
        }>;
        SSEPayloadAttributesCommon: ContainerType<{
            proposerIndex: UintNumberType;
            proposalSlot: UintNumberType;
            parentBlockNumber: UintNumberType;
            parentBlockRoot: ByteVectorType;
            parentBlockHash: ByteVectorType;
        }>;
        SSEPayloadAttributes: ContainerType<{
            proposerIndex: UintNumberType;
            proposalSlot: UintNumberType;
            parentBlockNumber: UintNumberType;
            parentBlockRoot: ByteVectorType;
            parentBlockHash: ByteVectorType;
            payloadAttributes: ContainerType<{
                timestamp: UintNumberType;
                prevRandao: ByteVectorType;
                suggestedFeeRecipient: StringType<string>;
            }>;
        }>;
    };
    capella: {
        AttestationSubnets: BitVectorType;
        BeaconBlockHeader: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        BeaconBlockHeaderBigint: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        SignedBeaconBlockHeader: ContainerType<{
            message: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        SignedBeaconBlockHeaderBigint: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        Checkpoint: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
        }>;
        CheckpointBigint: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
        }>;
        CommitteeBits: BitListType;
        CommitteeIndices: ListBasicType<UintNumberType>;
        DepositMessage: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
        }>;
        DepositData: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
        }>;
        DepositDataRootList: ListCompositeType<ByteVectorType>;
        DepositEvent: ContainerType<{
            depositData: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
            }>;
            blockNumber: UintNumberType;
            index: UintNumberType;
        }>;
        Eth1Data: ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
        }>;
        Eth1DataVotes: ListCompositeType<ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
        }>>;
        Eth1DataOrdered: ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
            blockNumber: UintNumberType;
        }>;
        Eth1Block: ContainerType<{
            timestamp: UintNumberType;
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
        }>;
        Fork: ContainerType<{
            previousVersion: ByteVectorType;
            currentVersion: ByteVectorType;
            epoch: UintNumberType;
        }>;
        ForkData: ContainerType<{
            currentVersion: ByteVectorType;
            genesisValidatorsRoot: ByteVectorType;
        }>;
        ENRForkID: ContainerType<{
            forkDigest: ByteVectorType;
            nextForkVersion: ByteVectorType;
            nextForkEpoch: UintNumberType;
        }>;
        HistoricalBlockRoots: VectorCompositeType<ByteVectorType>;
        HistoricalStateRoots: VectorCompositeType<ByteVectorType>;
        HistoricalBatch: ContainerType<{
            blockRoots: VectorCompositeType<ByteVectorType>;
            stateRoots: VectorCompositeType<ByteVectorType>;
        }>;
        HistoricalBatchRoots: ContainerType<{
            blockRoots: ByteVectorType;
            stateRoots: ByteVectorType;
        }>;
        Validator: ValidatorNodeStructType;
        Validators: ListCompositeType<ValidatorNodeStructType>;
        Balances: ListUintNum64Type;
        RandaoMixes: VectorCompositeType<ByteVectorType>;
        Slashings: VectorBasicType<UintNumberType>;
        JustificationBits: BitVectorType;
        AttestationData: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
        }>;
        AttestationDataBigint: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
            }>;
        }>;
        IndexedAttestation: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        IndexedAttestationBigint: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        PendingAttestation: ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            inclusionDelay: UintNumberType;
            proposerIndex: UintNumberType;
        }>;
        SigningData: ContainerType<{
            objectRoot: ByteVectorType;
            domain: ByteVectorType;
        }>;
        Attestation: ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        SingleAttestation: ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        AttesterSlashing: ContainerType<{
            attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
        }>;
        Deposit: ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
            }>;
        }>;
        ProposerSlashing: ContainerType<{
            signedHeader1: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
        }>;
        VoluntaryExit: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
        }>;
        SignedVoluntaryExit: ContainerType<{
            message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
        }>;
        EpochAttestations: ListCompositeType<ContainerType<{
        aggregationBits: BitListType;
        data: ContainerType<{
        slot: UintNumberType;
        index: UintNumberType;
        beaconBlockRoot: ByteVectorType;
        source: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
        }>;
        target: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
        }>;
        }>;
        inclusionDelay: UintNumberType;
        proposerIndex: UintNumberType;
        }>>;
        CommitteeAssignment: ContainerType<{
            validators: ListBasicType<UintNumberType>;
            committeeIndex: UintNumberType;
            slot: UintNumberType;
        }>;
        AggregateAndProof: ContainerType<{
            aggregatorIndex: UintNumberType;
            aggregate: ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            selectionProof: ByteVectorType;
        }>;
        SignedAggregateAndProof: ContainerType<{
            message: ContainerType<{
                aggregatorIndex: UintNumberType;
                aggregate: ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                        slot: UintNumberType;
                        index: UintNumberType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintNumberType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintNumberType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
                selectionProof: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        Status: ContainerType<{
            forkDigest: ByteVectorType;
            finalizedRoot: ByteVectorType;
            finalizedEpoch: UintNumberType;
            headRoot: ByteVectorType;
            headSlot: UintNumberType;
        }>;
        Goodbye: UintBigintType;
        Ping: UintBigintType;
        BeaconBlocksByRangeRequest: ContainerType<{
            startSlot: UintNumberType;
            count: UintNumberType;
            step: UintNumberType;
        }>;
        Genesis: ContainerType<{
            genesisValidatorsRoot: ByteVectorType;
            genesisTime: UintNumberType;
            genesisForkVersion: ByteVectorType;
        }>;
        SyncSubnets: BitVectorType;
        FinalityBranch: VectorCompositeType<ByteVectorType>;
        CurrentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
        NextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
        Metadata: ContainerType<{
            seqNumber: UintBigintType;
            attnets: BitVectorType;
            syncnets: BitVectorType;
        }>;
        SyncCommittee: ContainerType<{
            pubkeys: VectorCompositeType<ByteVectorType>;
            aggregatePubkey: ByteVectorType;
        }>;
        SyncCommitteeMessage: ContainerType<{
            slot: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            validatorIndex: UintNumberType;
            signature: ByteVectorType;
        }>;
        SyncCommitteeContribution: ContainerType<{
            slot: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            subcommitteeIndex: UintNumberType;
            aggregationBits: BitVectorType;
            signature: ByteVectorType;
        }>;
        ContributionAndProof: ContainerType<{
            aggregatorIndex: UintNumberType;
            contribution: ContainerType<{
                slot: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                subcommitteeIndex: UintNumberType;
                aggregationBits: BitVectorType;
                signature: ByteVectorType;
            }>;
            selectionProof: ByteVectorType;
        }>;
        SignedContributionAndProof: ContainerType<{
            message: ContainerType<{
                aggregatorIndex: UintNumberType;
                contribution: ContainerType<{
                    slot: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    subcommitteeIndex: UintNumberType;
                    aggregationBits: BitVectorType;
                    signature: ByteVectorType;
                }>;
                selectionProof: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        SyncAggregatorSelectionData: ContainerType<{
            slot: UintNumberType;
            subcommitteeIndex: UintNumberType;
        }>;
        SyncCommitteeBits: BitVectorType;
        SyncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
        }>;
        EpochParticipation: ListBasicType<UintNumberType>;
        InactivityScores: ListBasicType<UintNumberType>;
        LightClientUpdatesByRange: ContainerType<{
            startPeriod: UintNumberType;
            count: UintNumberType;
        }>;
        Transaction: ByteListType;
        Transactions: ListCompositeType<ByteListType>;
        CommonExecutionPayloadType: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
        }>;
        PowBlock: ContainerType<{
            blockHash: ByteVectorType;
            parentHash: ByteVectorType;
            totalDifficulty: UintBigintType;
        }>;
        ValidatorRegistrationV1: ContainerType<{
            feeRecipient: ExecutionAddressType;
            gasLimit: UintNumberType;
            timestamp: UintNumberType;
            pubkey: ByteVectorType;
        }>;
        SignedValidatorRegistrationV1: ContainerType<{
            message: ContainerType<{
                feeRecipient: ExecutionAddressType;
                gasLimit: UintNumberType;
                timestamp: UintNumberType;
                pubkey: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        SSEPayloadAttributesCommon: ContainerType<{
            proposerIndex: UintNumberType;
            proposalSlot: UintNumberType;
            parentBlockNumber: UintNumberType;
            parentBlockRoot: ByteVectorType;
            parentBlockHash: ByteVectorType;
        }>;
        ExecutionBranch: VectorCompositeType<ByteVectorType>;
        Withdrawal: ContainerType<{
            index: UintNumberType;
            validatorIndex: UintNumberType;
            address: ExecutionAddressType;
            amount: UintBigintType;
        }>;
        BLSToExecutionChange: ContainerType<{
            validatorIndex: UintNumberType;
            fromBlsPubkey: ByteVectorType;
            toExecutionAddress: ExecutionAddressType;
        }>;
        SignedBLSToExecutionChange: ContainerType<{
            message: ContainerType<{
                validatorIndex: UintNumberType;
                fromBlsPubkey: ByteVectorType;
                toExecutionAddress: ExecutionAddressType;
            }>;
            signature: ByteVectorType;
        }>;
        Withdrawals: ListCompositeType<ContainerType<{
        index: UintNumberType;
        validatorIndex: UintNumberType;
        address: ExecutionAddressType;
        amount: UintBigintType;
        }>>;
        ExecutionPayload: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactions: ListCompositeType<ByteListType>;
            withdrawals: ListCompositeType<ContainerType<{
            index: UintNumberType;
            validatorIndex: UintNumberType;
            address: ExecutionAddressType;
            amount: UintBigintType;
            }>>;
        }>;
        ExecutionPayloadHeader: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
        }>;
        BLSToExecutionChanges: ListCompositeType<ContainerType<{
        message: ContainerType<{
        validatorIndex: UintNumberType;
        fromBlsPubkey: ByteVectorType;
        toExecutionAddress: ExecutionAddressType;
        }>;
        signature: ByteVectorType;
        }>>;
        BeaconBlockBody: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
            signedHeader1: ContainerType<{
            message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
            message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
            }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
            attestation1: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
            message: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
            }>>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            executionPayload: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactions: ListCompositeType<ByteListType>;
                withdrawals: ListCompositeType<ContainerType<{
                index: UintNumberType;
                validatorIndex: UintNumberType;
                address: ExecutionAddressType;
                amount: UintBigintType;
                }>>;
            }>;
            blsToExecutionChanges: ListCompositeType<ContainerType<{
            message: ContainerType<{
            validatorIndex: UintNumberType;
            fromBlsPubkey: ByteVectorType;
            toExecutionAddress: ExecutionAddressType;
            }>;
            signature: ByteVectorType;
            }>>;
        }>;
        BeaconBlock: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            body: ContainerType<{
                randaoReveal: ByteVectorType;
                eth1Data: ContainerType<{
                    depositRoot: ByteVectorType;
                    depositCount: UintNumberType;
                    blockHash: ByteVectorType;
                }>;
                graffiti: ByteVectorType;
                proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
                }>;
                }>>;
                attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>;
                }>>;
                attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>>;
                deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                }>;
                }>>;
                voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
                }>>;
                syncAggregate: ContainerType<{
                    syncCommitteeBits: BitVectorType;
                    syncCommitteeSignature: ByteVectorType;
                }>;
                executionPayload: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactions: ListCompositeType<ByteListType>;
                    withdrawals: ListCompositeType<ContainerType<{
                    index: UintNumberType;
                    validatorIndex: UintNumberType;
                    address: ExecutionAddressType;
                    amount: UintBigintType;
                    }>>;
                }>;
                blsToExecutionChanges: ListCompositeType<ContainerType<{
                message: ContainerType<{
                validatorIndex: UintNumberType;
                fromBlsPubkey: ByteVectorType;
                toExecutionAddress: ExecutionAddressType;
                }>;
                signature: ByteVectorType;
                }>>;
            }>;
        }>;
        SignedBeaconBlock: ContainerType<{
            message: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                body: ContainerType<{
                    randaoReveal: ByteVectorType;
                    eth1Data: ContainerType<{
                        depositRoot: ByteVectorType;
                        depositCount: UintNumberType;
                        blockHash: ByteVectorType;
                    }>;
                    graffiti: ByteVectorType;
                    proposerSlashings: ListCompositeType<ContainerType<{
                    signedHeader1: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    signedHeader2: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attesterSlashings: ListCompositeType<ContainerType<{
                    attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attestations: ListCompositeType<ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    deposits: ListCompositeType<ContainerType<{
                    proof: VectorCompositeType<ByteVectorType>;
                    data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    voluntaryExits: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    syncAggregate: ContainerType<{
                        syncCommitteeBits: BitVectorType;
                        syncCommitteeSignature: ByteVectorType;
                    }>;
                    executionPayload: ContainerType<{
                        parentHash: ByteVectorType;
                        feeRecipient: ExecutionAddressType;
                        stateRoot: ByteVectorType;
                        receiptsRoot: ByteVectorType;
                        logsBloom: ByteVectorType;
                        prevRandao: ByteVectorType;
                        blockNumber: UintNumberType;
                        gasLimit: UintNumberType;
                        gasUsed: UintNumberType;
                        timestamp: UintNumberType;
                        extraData: ByteListType;
                        baseFeePerGas: UintBigintType;
                        blockHash: ByteVectorType;
                        transactions: ListCompositeType<ByteListType>;
                        withdrawals: ListCompositeType<ContainerType<{
                        index: UintNumberType;
                        validatorIndex: UintNumberType;
                        address: ExecutionAddressType;
                        amount: UintBigintType;
                        }>>;
                    }>;
                    blsToExecutionChanges: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    validatorIndex: UintNumberType;
                    fromBlsPubkey: ByteVectorType;
                    toExecutionAddress: ExecutionAddressType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        BuilderBid: ContainerType<{
            header: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
            }>;
            value: UintBigintType;
            pubkey: ByteVectorType;
        }>;
        SignedBuilderBid: ContainerType<{
            message: ContainerType<{
                header: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                }>;
                value: UintBigintType;
                pubkey: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        HistoricalSummary: ContainerType<{
            blockSummaryRoot: ByteVectorType;
            stateSummaryRoot: ByteVectorType;
        }>;
        HistoricalSummaries: ListCompositeType<ContainerType<{
        blockSummaryRoot: ByteVectorType;
        stateSummaryRoot: ByteVectorType;
        }>>;
        BeaconState: ContainerType<{
            genesisTime: UintNumberType;
            genesisValidatorsRoot: ByteVectorType;
            slot: UintNumberType;
            fork: ContainerType<{
                previousVersion: ByteVectorType;
                currentVersion: ByteVectorType;
                epoch: UintNumberType;
            }>;
            latestBlockHeader: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            blockRoots: VectorCompositeType<ByteVectorType>;
            stateRoots: VectorCompositeType<ByteVectorType>;
            historicalRoots: ListCompositeType<ByteVectorType>;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            eth1DataVotes: ListCompositeType<ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
            }>>;
            eth1DepositIndex: UintNumberType;
            validators: ListCompositeType<ValidatorNodeStructType>;
            balances: ListUintNum64Type;
            randaoMixes: VectorCompositeType<ByteVectorType>;
            slashings: VectorBasicType<UintNumberType>;
            previousEpochParticipation: ListBasicType<UintNumberType>;
            currentEpochParticipation: ListBasicType<UintNumberType>;
            justificationBits: BitVectorType;
            previousJustifiedCheckpoint: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            currentJustifiedCheckpoint: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            finalizedCheckpoint: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            inactivityScores: ListBasicType<UintNumberType>;
            currentSyncCommittee: ContainerType<{
                pubkeys: VectorCompositeType<ByteVectorType>;
                aggregatePubkey: ByteVectorType;
            }>;
            nextSyncCommittee: ContainerType<{
                pubkeys: VectorCompositeType<ByteVectorType>;
                aggregatePubkey: ByteVectorType;
            }>;
            latestExecutionPayloadHeader: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
            }>;
            nextWithdrawalIndex: UintNumberType;
            nextWithdrawalValidatorIndex: UintNumberType;
            historicalSummaries: ListCompositeType<ContainerType<{
            blockSummaryRoot: ByteVectorType;
            stateSummaryRoot: ByteVectorType;
            }>>;
        }>;
        BlindedBeaconBlockBody: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
            signedHeader1: ContainerType<{
            message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
            message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
            }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
            attestation1: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
            message: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
            }>>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            executionPayloadHeader: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
            }>;
            blsToExecutionChanges: ListCompositeType<ContainerType<{
            message: ContainerType<{
            validatorIndex: UintNumberType;
            fromBlsPubkey: ByteVectorType;
            toExecutionAddress: ExecutionAddressType;
            }>;
            signature: ByteVectorType;
            }>>;
        }>;
        BlindedBeaconBlock: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            body: ContainerType<{
                randaoReveal: ByteVectorType;
                eth1Data: ContainerType<{
                    depositRoot: ByteVectorType;
                    depositCount: UintNumberType;
                    blockHash: ByteVectorType;
                }>;
                graffiti: ByteVectorType;
                proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
                }>;
                }>>;
                attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>;
                }>>;
                attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>>;
                deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                }>;
                }>>;
                voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
                }>>;
                syncAggregate: ContainerType<{
                    syncCommitteeBits: BitVectorType;
                    syncCommitteeSignature: ByteVectorType;
                }>;
                executionPayloadHeader: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                }>;
                blsToExecutionChanges: ListCompositeType<ContainerType<{
                message: ContainerType<{
                validatorIndex: UintNumberType;
                fromBlsPubkey: ByteVectorType;
                toExecutionAddress: ExecutionAddressType;
                }>;
                signature: ByteVectorType;
                }>>;
            }>;
        }>;
        SignedBlindedBeaconBlock: ContainerType<{
            message: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                body: ContainerType<{
                    randaoReveal: ByteVectorType;
                    eth1Data: ContainerType<{
                        depositRoot: ByteVectorType;
                        depositCount: UintNumberType;
                        blockHash: ByteVectorType;
                    }>;
                    graffiti: ByteVectorType;
                    proposerSlashings: ListCompositeType<ContainerType<{
                    signedHeader1: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    signedHeader2: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attesterSlashings: ListCompositeType<ContainerType<{
                    attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attestations: ListCompositeType<ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    deposits: ListCompositeType<ContainerType<{
                    proof: VectorCompositeType<ByteVectorType>;
                    data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    voluntaryExits: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    syncAggregate: ContainerType<{
                        syncCommitteeBits: BitVectorType;
                        syncCommitteeSignature: ByteVectorType;
                    }>;
                    executionPayloadHeader: ContainerType<{
                        parentHash: ByteVectorType;
                        feeRecipient: ExecutionAddressType;
                        stateRoot: ByteVectorType;
                        receiptsRoot: ByteVectorType;
                        logsBloom: ByteVectorType;
                        prevRandao: ByteVectorType;
                        blockNumber: UintNumberType;
                        gasLimit: UintNumberType;
                        gasUsed: UintNumberType;
                        timestamp: UintNumberType;
                        extraData: ByteListType;
                        baseFeePerGas: UintBigintType;
                        blockHash: ByteVectorType;
                        transactionsRoot: ByteVectorType;
                        withdrawalsRoot: ByteVectorType;
                    }>;
                    blsToExecutionChanges: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    validatorIndex: UintNumberType;
                    fromBlsPubkey: ByteVectorType;
                    toExecutionAddress: ExecutionAddressType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        LightClientHeader: ContainerType<{
            beacon: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            execution: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
            }>;
            executionBranch: VectorCompositeType<ByteVectorType>;
        }>;
        LightClientBootstrap: ContainerType<{
            header: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            currentSyncCommittee: ContainerType<{
                pubkeys: VectorCompositeType<ByteVectorType>;
                aggregatePubkey: ByteVectorType;
            }>;
            currentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
        }>;
        LightClientUpdate: ContainerType<{
            attestedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            nextSyncCommittee: ContainerType<{
                pubkeys: VectorCompositeType<ByteVectorType>;
                aggregatePubkey: ByteVectorType;
            }>;
            nextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
            finalizedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            finalityBranch: VectorCompositeType<ByteVectorType>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            signatureSlot: UintNumberType;
        }>;
        LightClientFinalityUpdate: ContainerType<{
            attestedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            finalizedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            finalityBranch: VectorCompositeType<ByteVectorType>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            signatureSlot: UintNumberType;
        }>;
        LightClientOptimisticUpdate: ContainerType<{
            attestedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            signatureSlot: UintNumberType;
        }>;
        LightClientStore: ContainerType<{
            snapshot: ContainerType<{
                header: ContainerType<{
                    beacon: ContainerType<{
                        slot: UintNumberType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    execution: ContainerType<{
                        parentHash: ByteVectorType;
                        feeRecipient: ExecutionAddressType;
                        stateRoot: ByteVectorType;
                        receiptsRoot: ByteVectorType;
                        logsBloom: ByteVectorType;
                        prevRandao: ByteVectorType;
                        blockNumber: UintNumberType;
                        gasLimit: UintNumberType;
                        gasUsed: UintNumberType;
                        timestamp: UintNumberType;
                        extraData: ByteListType;
                        baseFeePerGas: UintBigintType;
                        blockHash: ByteVectorType;
                        transactionsRoot: ByteVectorType;
                        withdrawalsRoot: ByteVectorType;
                    }>;
                    executionBranch: VectorCompositeType<ByteVectorType>;
                }>;
                currentSyncCommittee: ContainerType<{
                    pubkeys: VectorCompositeType<ByteVectorType>;
                    aggregatePubkey: ByteVectorType;
                }>;
                currentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
            }>;
            validUpdates: ListCompositeType<ContainerType<{
            attestedHeader: ContainerType<{
            beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            execution: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            }>;
            executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            nextSyncCommittee: ContainerType<{
            pubkeys: VectorCompositeType<ByteVectorType>;
            aggregatePubkey: ByteVectorType;
            }>;
            nextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
            finalizedHeader: ContainerType<{
            beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            execution: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            }>;
            executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            finalityBranch: VectorCompositeType<ByteVectorType>;
            syncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
            }>;
            signatureSlot: UintNumberType;
            }>>;
        }>;
        PayloadAttributes: ContainerType<{
            timestamp: UintNumberType;
            prevRandao: ByteVectorType;
            suggestedFeeRecipient: StringType<string>;
            withdrawals: ListCompositeType<ContainerType<{
            index: UintNumberType;
            validatorIndex: UintNumberType;
            address: ExecutionAddressType;
            amount: UintBigintType;
            }>>;
        }>;
        SSEPayloadAttributes: ContainerType<{
            proposerIndex: UintNumberType;
            proposalSlot: UintNumberType;
            parentBlockNumber: UintNumberType;
            parentBlockRoot: ByteVectorType;
            parentBlockHash: ByteVectorType;
            payloadAttributes: ContainerType<{
                timestamp: UintNumberType;
                prevRandao: ByteVectorType;
                suggestedFeeRecipient: StringType<string>;
                withdrawals: ListCompositeType<ContainerType<{
                index: UintNumberType;
                validatorIndex: UintNumberType;
                address: ExecutionAddressType;
                amount: UintBigintType;
                }>>;
            }>;
        }>;
    };
    deneb: {
        AttestationSubnets: BitVectorType;
        BeaconBlockHeader: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        BeaconBlockHeaderBigint: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        SignedBeaconBlockHeader: ContainerType<{
            message: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        SignedBeaconBlockHeaderBigint: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        Checkpoint: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
        }>;
        CheckpointBigint: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
        }>;
        CommitteeBits: BitListType;
        CommitteeIndices: ListBasicType<UintNumberType>;
        DepositMessage: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
        }>;
        DepositData: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
        }>;
        DepositDataRootList: ListCompositeType<ByteVectorType>;
        DepositEvent: ContainerType<{
            depositData: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
            }>;
            blockNumber: UintNumberType;
            index: UintNumberType;
        }>;
        Eth1Data: ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
        }>;
        Eth1DataVotes: ListCompositeType<ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
        }>>;
        Eth1DataOrdered: ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
            blockNumber: UintNumberType;
        }>;
        Eth1Block: ContainerType<{
            timestamp: UintNumberType;
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
        }>;
        Fork: ContainerType<{
            previousVersion: ByteVectorType;
            currentVersion: ByteVectorType;
            epoch: UintNumberType;
        }>;
        ForkData: ContainerType<{
            currentVersion: ByteVectorType;
            genesisValidatorsRoot: ByteVectorType;
        }>;
        ENRForkID: ContainerType<{
            forkDigest: ByteVectorType;
            nextForkVersion: ByteVectorType;
            nextForkEpoch: UintNumberType;
        }>;
        HistoricalBlockRoots: VectorCompositeType<ByteVectorType>;
        HistoricalStateRoots: VectorCompositeType<ByteVectorType>;
        HistoricalBatch: ContainerType<{
            blockRoots: VectorCompositeType<ByteVectorType>;
            stateRoots: VectorCompositeType<ByteVectorType>;
        }>;
        HistoricalBatchRoots: ContainerType<{
            blockRoots: ByteVectorType;
            stateRoots: ByteVectorType;
        }>;
        Validator: ValidatorNodeStructType;
        Validators: ListCompositeType<ValidatorNodeStructType>;
        Balances: ListUintNum64Type;
        RandaoMixes: VectorCompositeType<ByteVectorType>;
        Slashings: VectorBasicType<UintNumberType>;
        JustificationBits: BitVectorType;
        AttestationData: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
        }>;
        AttestationDataBigint: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
            }>;
        }>;
        IndexedAttestation: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        IndexedAttestationBigint: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        PendingAttestation: ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            inclusionDelay: UintNumberType;
            proposerIndex: UintNumberType;
        }>;
        SigningData: ContainerType<{
            objectRoot: ByteVectorType;
            domain: ByteVectorType;
        }>;
        Attestation: ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        SingleAttestation: ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        AttesterSlashing: ContainerType<{
            attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
        }>;
        Deposit: ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
            }>;
        }>;
        ProposerSlashing: ContainerType<{
            signedHeader1: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
        }>;
        VoluntaryExit: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
        }>;
        SignedVoluntaryExit: ContainerType<{
            message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
        }>;
        EpochAttestations: ListCompositeType<ContainerType<{
        aggregationBits: BitListType;
        data: ContainerType<{
        slot: UintNumberType;
        index: UintNumberType;
        beaconBlockRoot: ByteVectorType;
        source: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
        }>;
        target: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
        }>;
        }>;
        inclusionDelay: UintNumberType;
        proposerIndex: UintNumberType;
        }>>;
        CommitteeAssignment: ContainerType<{
            validators: ListBasicType<UintNumberType>;
            committeeIndex: UintNumberType;
            slot: UintNumberType;
        }>;
        AggregateAndProof: ContainerType<{
            aggregatorIndex: UintNumberType;
            aggregate: ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            selectionProof: ByteVectorType;
        }>;
        SignedAggregateAndProof: ContainerType<{
            message: ContainerType<{
                aggregatorIndex: UintNumberType;
                aggregate: ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                        slot: UintNumberType;
                        index: UintNumberType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintNumberType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintNumberType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                }>;
                selectionProof: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        Status: ContainerType<{
            forkDigest: ByteVectorType;
            finalizedRoot: ByteVectorType;
            finalizedEpoch: UintNumberType;
            headRoot: ByteVectorType;
            headSlot: UintNumberType;
        }>;
        Goodbye: UintBigintType;
        Ping: UintBigintType;
        BeaconBlocksByRangeRequest: ContainerType<{
            startSlot: UintNumberType;
            count: UintNumberType;
            step: UintNumberType;
        }>;
        Genesis: ContainerType<{
            genesisValidatorsRoot: ByteVectorType;
            genesisTime: UintNumberType;
            genesisForkVersion: ByteVectorType;
        }>;
        SyncSubnets: BitVectorType;
        FinalityBranch: VectorCompositeType<ByteVectorType>;
        CurrentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
        NextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
        Metadata: ContainerType<{
            seqNumber: UintBigintType;
            attnets: BitVectorType;
            syncnets: BitVectorType;
        }>;
        SyncCommittee: ContainerType<{
            pubkeys: VectorCompositeType<ByteVectorType>;
            aggregatePubkey: ByteVectorType;
        }>;
        SyncCommitteeMessage: ContainerType<{
            slot: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            validatorIndex: UintNumberType;
            signature: ByteVectorType;
        }>;
        SyncCommitteeContribution: ContainerType<{
            slot: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            subcommitteeIndex: UintNumberType;
            aggregationBits: BitVectorType;
            signature: ByteVectorType;
        }>;
        ContributionAndProof: ContainerType<{
            aggregatorIndex: UintNumberType;
            contribution: ContainerType<{
                slot: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                subcommitteeIndex: UintNumberType;
                aggregationBits: BitVectorType;
                signature: ByteVectorType;
            }>;
            selectionProof: ByteVectorType;
        }>;
        SignedContributionAndProof: ContainerType<{
            message: ContainerType<{
                aggregatorIndex: UintNumberType;
                contribution: ContainerType<{
                    slot: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    subcommitteeIndex: UintNumberType;
                    aggregationBits: BitVectorType;
                    signature: ByteVectorType;
                }>;
                selectionProof: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        SyncAggregatorSelectionData: ContainerType<{
            slot: UintNumberType;
            subcommitteeIndex: UintNumberType;
        }>;
        SyncCommitteeBits: BitVectorType;
        SyncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
        }>;
        EpochParticipation: ListBasicType<UintNumberType>;
        InactivityScores: ListBasicType<UintNumberType>;
        LightClientUpdatesByRange: ContainerType<{
            startPeriod: UintNumberType;
            count: UintNumberType;
        }>;
        Transaction: ByteListType;
        Transactions: ListCompositeType<ByteListType>;
        CommonExecutionPayloadType: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
        }>;
        PowBlock: ContainerType<{
            blockHash: ByteVectorType;
            parentHash: ByteVectorType;
            totalDifficulty: UintBigintType;
        }>;
        ValidatorRegistrationV1: ContainerType<{
            feeRecipient: ExecutionAddressType;
            gasLimit: UintNumberType;
            timestamp: UintNumberType;
            pubkey: ByteVectorType;
        }>;
        SignedValidatorRegistrationV1: ContainerType<{
            message: ContainerType<{
                feeRecipient: ExecutionAddressType;
                gasLimit: UintNumberType;
                timestamp: UintNumberType;
                pubkey: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        SSEPayloadAttributesCommon: ContainerType<{
            proposerIndex: UintNumberType;
            proposalSlot: UintNumberType;
            parentBlockNumber: UintNumberType;
            parentBlockRoot: ByteVectorType;
            parentBlockHash: ByteVectorType;
        }>;
        ExecutionBranch: VectorCompositeType<ByteVectorType>;
        Withdrawal: ContainerType<{
            index: UintNumberType;
            validatorIndex: UintNumberType;
            address: ExecutionAddressType;
            amount: UintBigintType;
        }>;
        BLSToExecutionChange: ContainerType<{
            validatorIndex: UintNumberType;
            fromBlsPubkey: ByteVectorType;
            toExecutionAddress: ExecutionAddressType;
        }>;
        SignedBLSToExecutionChange: ContainerType<{
            message: ContainerType<{
                validatorIndex: UintNumberType;
                fromBlsPubkey: ByteVectorType;
                toExecutionAddress: ExecutionAddressType;
            }>;
            signature: ByteVectorType;
        }>;
        Withdrawals: ListCompositeType<ContainerType<{
        index: UintNumberType;
        validatorIndex: UintNumberType;
        address: ExecutionAddressType;
        amount: UintBigintType;
        }>>;
        BLSToExecutionChanges: ListCompositeType<ContainerType<{
        message: ContainerType<{
        validatorIndex: UintNumberType;
        fromBlsPubkey: ByteVectorType;
        toExecutionAddress: ExecutionAddressType;
        }>;
        signature: ByteVectorType;
        }>>;
        HistoricalSummary: ContainerType<{
            blockSummaryRoot: ByteVectorType;
            stateSummaryRoot: ByteVectorType;
        }>;
        HistoricalSummaries: ListCompositeType<ContainerType<{
        blockSummaryRoot: ByteVectorType;
        stateSummaryRoot: ByteVectorType;
        }>>;
        G1Point: ByteVectorType;
        G2Point: ByteVectorType;
        BLSFieldElement: ByteVectorType;
        KZGCommitment: ByteVectorType;
        KZGProof: ByteVectorType;
        Blob: ByteVectorType;
        Blobs: ListCompositeType<ByteVectorType>;
        BlindedBlob: ByteVectorType;
        BlindedBlobs: ListCompositeType<ByteVectorType>;
        VersionedHash: ByteVectorType;
        BlobKzgCommitments: ListCompositeType<ByteVectorType>;
        KZGProofs: ListCompositeType<ByteVectorType>;
        BlobSidecarsByRangeRequest: ContainerType<{
            startSlot: UintNumberType;
            count: UintNumberType;
        }>;
        BlobIdentifier: ContainerType<{
            blockRoot: ByteVectorType;
            index: UintNumberType;
        }>;
        ExecutionPayload: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactions: ListCompositeType<ByteListType>;
            withdrawals: ListCompositeType<ContainerType<{
            index: UintNumberType;
            validatorIndex: UintNumberType;
            address: ExecutionAddressType;
            amount: UintBigintType;
            }>>;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
        }>;
        ExecutionPayloadHeader: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
        }>;
        BeaconBlockBody: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
            signedHeader1: ContainerType<{
            message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
            message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
            }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
            attestation1: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
            message: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
            }>>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            executionPayload: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactions: ListCompositeType<ByteListType>;
                withdrawals: ListCompositeType<ContainerType<{
                index: UintNumberType;
                validatorIndex: UintNumberType;
                address: ExecutionAddressType;
                amount: UintBigintType;
                }>>;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            blsToExecutionChanges: ListCompositeType<ContainerType<{
            message: ContainerType<{
            validatorIndex: UintNumberType;
            fromBlsPubkey: ByteVectorType;
            toExecutionAddress: ExecutionAddressType;
            }>;
            signature: ByteVectorType;
            }>>;
            blobKzgCommitments: ListCompositeType<ByteVectorType>;
        }>;
        BeaconBlock: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            body: ContainerType<{
                randaoReveal: ByteVectorType;
                eth1Data: ContainerType<{
                    depositRoot: ByteVectorType;
                    depositCount: UintNumberType;
                    blockHash: ByteVectorType;
                }>;
                graffiti: ByteVectorType;
                proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
                }>;
                }>>;
                attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>;
                }>>;
                attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>>;
                deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                }>;
                }>>;
                voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
                }>>;
                syncAggregate: ContainerType<{
                    syncCommitteeBits: BitVectorType;
                    syncCommitteeSignature: ByteVectorType;
                }>;
                executionPayload: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactions: ListCompositeType<ByteListType>;
                    withdrawals: ListCompositeType<ContainerType<{
                    index: UintNumberType;
                    validatorIndex: UintNumberType;
                    address: ExecutionAddressType;
                    amount: UintBigintType;
                    }>>;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                blsToExecutionChanges: ListCompositeType<ContainerType<{
                message: ContainerType<{
                validatorIndex: UintNumberType;
                fromBlsPubkey: ByteVectorType;
                toExecutionAddress: ExecutionAddressType;
                }>;
                signature: ByteVectorType;
                }>>;
                blobKzgCommitments: ListCompositeType<ByteVectorType>;
            }>;
        }>;
        SignedBeaconBlock: ContainerType<{
            message: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                body: ContainerType<{
                    randaoReveal: ByteVectorType;
                    eth1Data: ContainerType<{
                        depositRoot: ByteVectorType;
                        depositCount: UintNumberType;
                        blockHash: ByteVectorType;
                    }>;
                    graffiti: ByteVectorType;
                    proposerSlashings: ListCompositeType<ContainerType<{
                    signedHeader1: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    signedHeader2: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attesterSlashings: ListCompositeType<ContainerType<{
                    attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attestations: ListCompositeType<ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    deposits: ListCompositeType<ContainerType<{
                    proof: VectorCompositeType<ByteVectorType>;
                    data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    voluntaryExits: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    syncAggregate: ContainerType<{
                        syncCommitteeBits: BitVectorType;
                        syncCommitteeSignature: ByteVectorType;
                    }>;
                    executionPayload: ContainerType<{
                        parentHash: ByteVectorType;
                        feeRecipient: ExecutionAddressType;
                        stateRoot: ByteVectorType;
                        receiptsRoot: ByteVectorType;
                        logsBloom: ByteVectorType;
                        prevRandao: ByteVectorType;
                        blockNumber: UintNumberType;
                        gasLimit: UintNumberType;
                        gasUsed: UintNumberType;
                        timestamp: UintNumberType;
                        extraData: ByteListType;
                        baseFeePerGas: UintBigintType;
                        blockHash: ByteVectorType;
                        transactions: ListCompositeType<ByteListType>;
                        withdrawals: ListCompositeType<ContainerType<{
                        index: UintNumberType;
                        validatorIndex: UintNumberType;
                        address: ExecutionAddressType;
                        amount: UintBigintType;
                        }>>;
                        blobGasUsed: UintBigintType;
                        excessBlobGas: UintBigintType;
                    }>;
                    blsToExecutionChanges: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    validatorIndex: UintNumberType;
                    fromBlsPubkey: ByteVectorType;
                    toExecutionAddress: ExecutionAddressType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    blobKzgCommitments: ListCompositeType<ByteVectorType>;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        KzgCommitmentInclusionProof: VectorCompositeType<ByteVectorType>;
        BlobSidecar: ContainerType<{
            index: UintNumberType;
            blob: ByteVectorType;
            kzgCommitment: ByteVectorType;
            kzgProof: ByteVectorType;
            signedBlockHeader: ContainerType<{
                message: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
            kzgCommitmentInclusionProof: VectorCompositeType<ByteVectorType>;
        }>;
        BlobSidecars: ListCompositeType<ContainerType<{
        index: UintNumberType;
        blob: ByteVectorType;
        kzgCommitment: ByteVectorType;
        kzgProof: ByteVectorType;
        signedBlockHeader: ContainerType<{
        message: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
        }>;
        signature: ByteVectorType;
        }>;
        kzgCommitmentInclusionProof: VectorCompositeType<ByteVectorType>;
        }>>;
        BlobsBundle: ContainerType<{
            commitments: ListCompositeType<ByteVectorType>;
            proofs: ListCompositeType<ByteVectorType>;
            blobs: ListCompositeType<ByteVectorType>;
        }>;
        BlindedBeaconBlockBody: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
            signedHeader1: ContainerType<{
            message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
            message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
            }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
            attestation1: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
            message: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
            }>>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            executionPayloadHeader: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            blsToExecutionChanges: ListCompositeType<ContainerType<{
            message: ContainerType<{
            validatorIndex: UintNumberType;
            fromBlsPubkey: ByteVectorType;
            toExecutionAddress: ExecutionAddressType;
            }>;
            signature: ByteVectorType;
            }>>;
            blobKzgCommitments: ListCompositeType<ByteVectorType>;
        }>;
        BlindedBeaconBlock: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            body: ContainerType<{
                randaoReveal: ByteVectorType;
                eth1Data: ContainerType<{
                    depositRoot: ByteVectorType;
                    depositCount: UintNumberType;
                    blockHash: ByteVectorType;
                }>;
                graffiti: ByteVectorType;
                proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
                }>;
                }>>;
                attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>;
                }>>;
                attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>>;
                deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                }>;
                }>>;
                voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
                }>>;
                syncAggregate: ContainerType<{
                    syncCommitteeBits: BitVectorType;
                    syncCommitteeSignature: ByteVectorType;
                }>;
                executionPayloadHeader: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                blsToExecutionChanges: ListCompositeType<ContainerType<{
                message: ContainerType<{
                validatorIndex: UintNumberType;
                fromBlsPubkey: ByteVectorType;
                toExecutionAddress: ExecutionAddressType;
                }>;
                signature: ByteVectorType;
                }>>;
                blobKzgCommitments: ListCompositeType<ByteVectorType>;
            }>;
        }>;
        SignedBlindedBeaconBlock: ContainerType<{
            message: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                body: ContainerType<{
                    randaoReveal: ByteVectorType;
                    eth1Data: ContainerType<{
                        depositRoot: ByteVectorType;
                        depositCount: UintNumberType;
                        blockHash: ByteVectorType;
                    }>;
                    graffiti: ByteVectorType;
                    proposerSlashings: ListCompositeType<ContainerType<{
                    signedHeader1: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    signedHeader2: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attesterSlashings: ListCompositeType<ContainerType<{
                    attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attestations: ListCompositeType<ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    deposits: ListCompositeType<ContainerType<{
                    proof: VectorCompositeType<ByteVectorType>;
                    data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    voluntaryExits: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    syncAggregate: ContainerType<{
                        syncCommitteeBits: BitVectorType;
                        syncCommitteeSignature: ByteVectorType;
                    }>;
                    executionPayloadHeader: ContainerType<{
                        parentHash: ByteVectorType;
                        feeRecipient: ExecutionAddressType;
                        stateRoot: ByteVectorType;
                        receiptsRoot: ByteVectorType;
                        logsBloom: ByteVectorType;
                        prevRandao: ByteVectorType;
                        blockNumber: UintNumberType;
                        gasLimit: UintNumberType;
                        gasUsed: UintNumberType;
                        timestamp: UintNumberType;
                        extraData: ByteListType;
                        baseFeePerGas: UintBigintType;
                        blockHash: ByteVectorType;
                        transactionsRoot: ByteVectorType;
                        withdrawalsRoot: ByteVectorType;
                        blobGasUsed: UintBigintType;
                        excessBlobGas: UintBigintType;
                    }>;
                    blsToExecutionChanges: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    validatorIndex: UintNumberType;
                    fromBlsPubkey: ByteVectorType;
                    toExecutionAddress: ExecutionAddressType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    blobKzgCommitments: ListCompositeType<ByteVectorType>;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        BuilderBid: ContainerType<{
            header: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            blobKzgCommitments: ListCompositeType<ByteVectorType>;
            value: UintBigintType;
            pubkey: ByteVectorType;
        }>;
        SignedBuilderBid: ContainerType<{
            message: ContainerType<{
                header: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                blobKzgCommitments: ListCompositeType<ByteVectorType>;
                value: UintBigintType;
                pubkey: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        ExecutionPayloadAndBlobsBundle: ContainerType<{
            executionPayload: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactions: ListCompositeType<ByteListType>;
                withdrawals: ListCompositeType<ContainerType<{
                index: UintNumberType;
                validatorIndex: UintNumberType;
                address: ExecutionAddressType;
                amount: UintBigintType;
                }>>;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            blobsBundle: ContainerType<{
                commitments: ListCompositeType<ByteVectorType>;
                proofs: ListCompositeType<ByteVectorType>;
                blobs: ListCompositeType<ByteVectorType>;
            }>;
        }>;
        BeaconState: ContainerType<{
            genesisTime: UintNumberType;
            genesisValidatorsRoot: ByteVectorType;
            slot: UintNumberType;
            fork: ContainerType<{
                previousVersion: ByteVectorType;
                currentVersion: ByteVectorType;
                epoch: UintNumberType;
            }>;
            latestBlockHeader: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            blockRoots: VectorCompositeType<ByteVectorType>;
            stateRoots: VectorCompositeType<ByteVectorType>;
            historicalRoots: ListCompositeType<ByteVectorType>;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            eth1DataVotes: ListCompositeType<ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
            }>>;
            eth1DepositIndex: UintNumberType;
            validators: ListCompositeType<ValidatorNodeStructType>;
            balances: ListUintNum64Type;
            randaoMixes: VectorCompositeType<ByteVectorType>;
            slashings: VectorBasicType<UintNumberType>;
            previousEpochParticipation: ListBasicType<UintNumberType>;
            currentEpochParticipation: ListBasicType<UintNumberType>;
            justificationBits: BitVectorType;
            previousJustifiedCheckpoint: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            currentJustifiedCheckpoint: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            finalizedCheckpoint: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            inactivityScores: ListBasicType<UintNumberType>;
            currentSyncCommittee: ContainerType<{
                pubkeys: VectorCompositeType<ByteVectorType>;
                aggregatePubkey: ByteVectorType;
            }>;
            nextSyncCommittee: ContainerType<{
                pubkeys: VectorCompositeType<ByteVectorType>;
                aggregatePubkey: ByteVectorType;
            }>;
            latestExecutionPayloadHeader: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            nextWithdrawalIndex: UintNumberType;
            nextWithdrawalValidatorIndex: UintNumberType;
            historicalSummaries: ListCompositeType<ContainerType<{
            blockSummaryRoot: ByteVectorType;
            stateSummaryRoot: ByteVectorType;
            }>>;
        }>;
        LightClientHeader: ContainerType<{
            beacon: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            execution: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            executionBranch: VectorCompositeType<ByteVectorType>;
        }>;
        LightClientBootstrap: ContainerType<{
            header: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            currentSyncCommittee: ContainerType<{
                pubkeys: VectorCompositeType<ByteVectorType>;
                aggregatePubkey: ByteVectorType;
            }>;
            currentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
        }>;
        LightClientUpdate: ContainerType<{
            attestedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            nextSyncCommittee: ContainerType<{
                pubkeys: VectorCompositeType<ByteVectorType>;
                aggregatePubkey: ByteVectorType;
            }>;
            nextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
            finalizedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            finalityBranch: VectorCompositeType<ByteVectorType>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            signatureSlot: UintNumberType;
        }>;
        LightClientFinalityUpdate: ContainerType<{
            attestedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            finalizedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            finalityBranch: VectorCompositeType<ByteVectorType>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            signatureSlot: UintNumberType;
        }>;
        LightClientOptimisticUpdate: ContainerType<{
            attestedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            signatureSlot: UintNumberType;
        }>;
        LightClientStore: ContainerType<{
            snapshot: ContainerType<{
                header: ContainerType<{
                    beacon: ContainerType<{
                        slot: UintNumberType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    execution: ContainerType<{
                        parentHash: ByteVectorType;
                        feeRecipient: ExecutionAddressType;
                        stateRoot: ByteVectorType;
                        receiptsRoot: ByteVectorType;
                        logsBloom: ByteVectorType;
                        prevRandao: ByteVectorType;
                        blockNumber: UintNumberType;
                        gasLimit: UintNumberType;
                        gasUsed: UintNumberType;
                        timestamp: UintNumberType;
                        extraData: ByteListType;
                        baseFeePerGas: UintBigintType;
                        blockHash: ByteVectorType;
                        transactionsRoot: ByteVectorType;
                        withdrawalsRoot: ByteVectorType;
                        blobGasUsed: UintBigintType;
                        excessBlobGas: UintBigintType;
                    }>;
                    executionBranch: VectorCompositeType<ByteVectorType>;
                }>;
                currentSyncCommittee: ContainerType<{
                    pubkeys: VectorCompositeType<ByteVectorType>;
                    aggregatePubkey: ByteVectorType;
                }>;
                currentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
            }>;
            validUpdates: ListCompositeType<ContainerType<{
            attestedHeader: ContainerType<{
            beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            execution: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
            }>;
            executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            nextSyncCommittee: ContainerType<{
            pubkeys: VectorCompositeType<ByteVectorType>;
            aggregatePubkey: ByteVectorType;
            }>;
            nextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
            finalizedHeader: ContainerType<{
            beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            execution: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
            }>;
            executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            finalityBranch: VectorCompositeType<ByteVectorType>;
            syncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
            }>;
            signatureSlot: UintNumberType;
            }>>;
        }>;
        PayloadAttributes: ContainerType<{
            timestamp: UintNumberType;
            prevRandao: ByteVectorType;
            suggestedFeeRecipient: StringType<string>;
            withdrawals: ListCompositeType<ContainerType<{
            index: UintNumberType;
            validatorIndex: UintNumberType;
            address: ExecutionAddressType;
            amount: UintBigintType;
            }>>;
            parentBeaconBlockRoot: ByteVectorType;
        }>;
        SSEPayloadAttributes: ContainerType<{
            proposerIndex: UintNumberType;
            proposalSlot: UintNumberType;
            parentBlockNumber: UintNumberType;
            parentBlockRoot: ByteVectorType;
            parentBlockHash: ByteVectorType;
            payloadAttributes: ContainerType<{
                timestamp: UintNumberType;
                prevRandao: ByteVectorType;
                suggestedFeeRecipient: StringType<string>;
                withdrawals: ListCompositeType<ContainerType<{
                index: UintNumberType;
                validatorIndex: UintNumberType;
                address: ExecutionAddressType;
                amount: UintBigintType;
                }>>;
                parentBeaconBlockRoot: ByteVectorType;
            }>;
        }>;
        BlockContents: ContainerType<{
            block: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                body: ContainerType<{
                    randaoReveal: ByteVectorType;
                    eth1Data: ContainerType<{
                        depositRoot: ByteVectorType;
                        depositCount: UintNumberType;
                        blockHash: ByteVectorType;
                    }>;
                    graffiti: ByteVectorType;
                    proposerSlashings: ListCompositeType<ContainerType<{
                    signedHeader1: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    signedHeader2: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attesterSlashings: ListCompositeType<ContainerType<{
                    attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attestations: ListCompositeType<ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    deposits: ListCompositeType<ContainerType<{
                    proof: VectorCompositeType<ByteVectorType>;
                    data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    voluntaryExits: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    syncAggregate: ContainerType<{
                        syncCommitteeBits: BitVectorType;
                        syncCommitteeSignature: ByteVectorType;
                    }>;
                    executionPayload: ContainerType<{
                        parentHash: ByteVectorType;
                        feeRecipient: ExecutionAddressType;
                        stateRoot: ByteVectorType;
                        receiptsRoot: ByteVectorType;
                        logsBloom: ByteVectorType;
                        prevRandao: ByteVectorType;
                        blockNumber: UintNumberType;
                        gasLimit: UintNumberType;
                        gasUsed: UintNumberType;
                        timestamp: UintNumberType;
                        extraData: ByteListType;
                        baseFeePerGas: UintBigintType;
                        blockHash: ByteVectorType;
                        transactions: ListCompositeType<ByteListType>;
                        withdrawals: ListCompositeType<ContainerType<{
                        index: UintNumberType;
                        validatorIndex: UintNumberType;
                        address: ExecutionAddressType;
                        amount: UintBigintType;
                        }>>;
                        blobGasUsed: UintBigintType;
                        excessBlobGas: UintBigintType;
                    }>;
                    blsToExecutionChanges: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    validatorIndex: UintNumberType;
                    fromBlsPubkey: ByteVectorType;
                    toExecutionAddress: ExecutionAddressType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    blobKzgCommitments: ListCompositeType<ByteVectorType>;
                }>;
            }>;
            kzgProofs: ListCompositeType<ByteVectorType>;
            blobs: ListCompositeType<ByteVectorType>;
        }>;
        SignedBlockContents: ContainerType<{
            signedBlock: ContainerType<{
                message: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    body: ContainerType<{
                        randaoReveal: ByteVectorType;
                        eth1Data: ContainerType<{
                            depositRoot: ByteVectorType;
                            depositCount: UintNumberType;
                            blockHash: ByteVectorType;
                        }>;
                        graffiti: ByteVectorType;
                        proposerSlashings: ListCompositeType<ContainerType<{
                        signedHeader1: ContainerType<{
                        message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                        }>;
                        signature: ByteVectorType;
                        }>;
                        signedHeader2: ContainerType<{
                        message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                        }>;
                        signature: ByteVectorType;
                        }>;
                        }>>;
                        attesterSlashings: ListCompositeType<ContainerType<{
                        attestation1: ContainerType<{
                        attestingIndices: ListBasicType<UintNumberType>;
                        data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                        }>;
                        }>;
                        signature: ByteVectorType;
                        }>;
                        attestation2: ContainerType<{
                        attestingIndices: ListBasicType<UintNumberType>;
                        data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                        }>;
                        }>;
                        signature: ByteVectorType;
                        }>;
                        }>>;
                        attestations: ListCompositeType<ContainerType<{
                        aggregationBits: BitListType;
                        data: ContainerType<{
                        slot: UintNumberType;
                        index: UintNumberType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                        }>;
                        }>;
                        signature: ByteVectorType;
                        }>>;
                        deposits: ListCompositeType<ContainerType<{
                        proof: VectorCompositeType<ByteVectorType>;
                        data: ContainerType<{
                        pubkey: ByteVectorType;
                        withdrawalCredentials: ByteVectorType;
                        amount: UintNumberType;
                        signature: ByteVectorType;
                        }>;
                        }>>;
                        voluntaryExits: ListCompositeType<ContainerType<{
                        message: ContainerType<{
                        epoch: UintNumberType;
                        validatorIndex: UintNumberType;
                        }>;
                        signature: ByteVectorType;
                        }>>;
                        syncAggregate: ContainerType<{
                            syncCommitteeBits: BitVectorType;
                            syncCommitteeSignature: ByteVectorType;
                        }>;
                        executionPayload: ContainerType<{
                            parentHash: ByteVectorType;
                            feeRecipient: ExecutionAddressType;
                            stateRoot: ByteVectorType;
                            receiptsRoot: ByteVectorType;
                            logsBloom: ByteVectorType;
                            prevRandao: ByteVectorType;
                            blockNumber: UintNumberType;
                            gasLimit: UintNumberType;
                            gasUsed: UintNumberType;
                            timestamp: UintNumberType;
                            extraData: ByteListType;
                            baseFeePerGas: UintBigintType;
                            blockHash: ByteVectorType;
                            transactions: ListCompositeType<ByteListType>;
                            withdrawals: ListCompositeType<ContainerType<{
                            index: UintNumberType;
                            validatorIndex: UintNumberType;
                            address: ExecutionAddressType;
                            amount: UintBigintType;
                            }>>;
                            blobGasUsed: UintBigintType;
                            excessBlobGas: UintBigintType;
                        }>;
                        blsToExecutionChanges: ListCompositeType<ContainerType<{
                        message: ContainerType<{
                        validatorIndex: UintNumberType;
                        fromBlsPubkey: ByteVectorType;
                        toExecutionAddress: ExecutionAddressType;
                        }>;
                        signature: ByteVectorType;
                        }>>;
                        blobKzgCommitments: ListCompositeType<ByteVectorType>;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            kzgProofs: ListCompositeType<ByteVectorType>;
            blobs: ListCompositeType<ByteVectorType>;
        }>;
    };
    electra: {
        AttestationSubnets: BitVectorType;
        BeaconBlockHeader: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        BeaconBlockHeaderBigint: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        SignedBeaconBlockHeader: ContainerType<{
            message: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        SignedBeaconBlockHeaderBigint: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        Checkpoint: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
        }>;
        CheckpointBigint: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
        }>;
        CommitteeIndices: ListBasicType<UintNumberType>;
        DepositMessage: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
        }>;
        DepositData: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
        }>;
        DepositDataRootList: ListCompositeType<ByteVectorType>;
        DepositEvent: ContainerType<{
            depositData: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
            }>;
            blockNumber: UintNumberType;
            index: UintNumberType;
        }>;
        Eth1Data: ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
        }>;
        Eth1DataVotes: ListCompositeType<ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
        }>>;
        Eth1DataOrdered: ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
            blockNumber: UintNumberType;
        }>;
        Eth1Block: ContainerType<{
            timestamp: UintNumberType;
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
        }>;
        Fork: ContainerType<{
            previousVersion: ByteVectorType;
            currentVersion: ByteVectorType;
            epoch: UintNumberType;
        }>;
        ForkData: ContainerType<{
            currentVersion: ByteVectorType;
            genesisValidatorsRoot: ByteVectorType;
        }>;
        ENRForkID: ContainerType<{
            forkDigest: ByteVectorType;
            nextForkVersion: ByteVectorType;
            nextForkEpoch: UintNumberType;
        }>;
        HistoricalBlockRoots: VectorCompositeType<ByteVectorType>;
        HistoricalStateRoots: VectorCompositeType<ByteVectorType>;
        HistoricalBatch: ContainerType<{
            blockRoots: VectorCompositeType<ByteVectorType>;
            stateRoots: VectorCompositeType<ByteVectorType>;
        }>;
        HistoricalBatchRoots: ContainerType<{
            blockRoots: ByteVectorType;
            stateRoots: ByteVectorType;
        }>;
        Validator: ValidatorNodeStructType;
        Validators: ListCompositeType<ValidatorNodeStructType>;
        Balances: ListUintNum64Type;
        RandaoMixes: VectorCompositeType<ByteVectorType>;
        Slashings: VectorBasicType<UintNumberType>;
        JustificationBits: BitVectorType;
        AttestationData: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
        }>;
        AttestationDataBigint: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
            }>;
        }>;
        PendingAttestation: ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            inclusionDelay: UintNumberType;
            proposerIndex: UintNumberType;
        }>;
        SigningData: ContainerType<{
            objectRoot: ByteVectorType;
            domain: ByteVectorType;
        }>;
        Deposit: ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
            }>;
        }>;
        ProposerSlashing: ContainerType<{
            signedHeader1: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
        }>;
        VoluntaryExit: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
        }>;
        SignedVoluntaryExit: ContainerType<{
            message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
        }>;
        EpochAttestations: ListCompositeType<ContainerType<{
        aggregationBits: BitListType;
        data: ContainerType<{
        slot: UintNumberType;
        index: UintNumberType;
        beaconBlockRoot: ByteVectorType;
        source: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
        }>;
        target: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
        }>;
        }>;
        inclusionDelay: UintNumberType;
        proposerIndex: UintNumberType;
        }>>;
        CommitteeAssignment: ContainerType<{
            validators: ListBasicType<UintNumberType>;
            committeeIndex: UintNumberType;
            slot: UintNumberType;
        }>;
        Status: ContainerType<{
            forkDigest: ByteVectorType;
            finalizedRoot: ByteVectorType;
            finalizedEpoch: UintNumberType;
            headRoot: ByteVectorType;
            headSlot: UintNumberType;
        }>;
        Goodbye: UintBigintType;
        Ping: UintBigintType;
        BeaconBlocksByRangeRequest: ContainerType<{
            startSlot: UintNumberType;
            count: UintNumberType;
            step: UintNumberType;
        }>;
        Genesis: ContainerType<{
            genesisValidatorsRoot: ByteVectorType;
            genesisTime: UintNumberType;
            genesisForkVersion: ByteVectorType;
        }>;
        SyncSubnets: BitVectorType;
        Metadata: ContainerType<{
            seqNumber: UintBigintType;
            attnets: BitVectorType;
            syncnets: BitVectorType;
        }>;
        SyncCommittee: ContainerType<{
            pubkeys: VectorCompositeType<ByteVectorType>;
            aggregatePubkey: ByteVectorType;
        }>;
        SyncCommitteeMessage: ContainerType<{
            slot: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            validatorIndex: UintNumberType;
            signature: ByteVectorType;
        }>;
        SyncCommitteeContribution: ContainerType<{
            slot: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            subcommitteeIndex: UintNumberType;
            aggregationBits: BitVectorType;
            signature: ByteVectorType;
        }>;
        ContributionAndProof: ContainerType<{
            aggregatorIndex: UintNumberType;
            contribution: ContainerType<{
                slot: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                subcommitteeIndex: UintNumberType;
                aggregationBits: BitVectorType;
                signature: ByteVectorType;
            }>;
            selectionProof: ByteVectorType;
        }>;
        SignedContributionAndProof: ContainerType<{
            message: ContainerType<{
                aggregatorIndex: UintNumberType;
                contribution: ContainerType<{
                    slot: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    subcommitteeIndex: UintNumberType;
                    aggregationBits: BitVectorType;
                    signature: ByteVectorType;
                }>;
                selectionProof: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        SyncAggregatorSelectionData: ContainerType<{
            slot: UintNumberType;
            subcommitteeIndex: UintNumberType;
        }>;
        SyncCommitteeBits: BitVectorType;
        SyncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
        }>;
        EpochParticipation: ListBasicType<UintNumberType>;
        InactivityScores: ListBasicType<UintNumberType>;
        LightClientUpdatesByRange: ContainerType<{
            startPeriod: UintNumberType;
            count: UintNumberType;
        }>;
        Transaction: ByteListType;
        Transactions: ListCompositeType<ByteListType>;
        CommonExecutionPayloadType: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
        }>;
        PowBlock: ContainerType<{
            blockHash: ByteVectorType;
            parentHash: ByteVectorType;
            totalDifficulty: UintBigintType;
        }>;
        ValidatorRegistrationV1: ContainerType<{
            feeRecipient: ExecutionAddressType;
            gasLimit: UintNumberType;
            timestamp: UintNumberType;
            pubkey: ByteVectorType;
        }>;
        SignedValidatorRegistrationV1: ContainerType<{
            message: ContainerType<{
                feeRecipient: ExecutionAddressType;
                gasLimit: UintNumberType;
                timestamp: UintNumberType;
                pubkey: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        SSEPayloadAttributesCommon: ContainerType<{
            proposerIndex: UintNumberType;
            proposalSlot: UintNumberType;
            parentBlockNumber: UintNumberType;
            parentBlockRoot: ByteVectorType;
            parentBlockHash: ByteVectorType;
        }>;
        ExecutionBranch: VectorCompositeType<ByteVectorType>;
        Withdrawal: ContainerType<{
            index: UintNumberType;
            validatorIndex: UintNumberType;
            address: ExecutionAddressType;
            amount: UintBigintType;
        }>;
        BLSToExecutionChange: ContainerType<{
            validatorIndex: UintNumberType;
            fromBlsPubkey: ByteVectorType;
            toExecutionAddress: ExecutionAddressType;
        }>;
        SignedBLSToExecutionChange: ContainerType<{
            message: ContainerType<{
                validatorIndex: UintNumberType;
                fromBlsPubkey: ByteVectorType;
                toExecutionAddress: ExecutionAddressType;
            }>;
            signature: ByteVectorType;
        }>;
        Withdrawals: ListCompositeType<ContainerType<{
        index: UintNumberType;
        validatorIndex: UintNumberType;
        address: ExecutionAddressType;
        amount: UintBigintType;
        }>>;
        BLSToExecutionChanges: ListCompositeType<ContainerType<{
        message: ContainerType<{
        validatorIndex: UintNumberType;
        fromBlsPubkey: ByteVectorType;
        toExecutionAddress: ExecutionAddressType;
        }>;
        signature: ByteVectorType;
        }>>;
        HistoricalSummary: ContainerType<{
            blockSummaryRoot: ByteVectorType;
            stateSummaryRoot: ByteVectorType;
        }>;
        HistoricalSummaries: ListCompositeType<ContainerType<{
        blockSummaryRoot: ByteVectorType;
        stateSummaryRoot: ByteVectorType;
        }>>;
        G1Point: ByteVectorType;
        G2Point: ByteVectorType;
        BLSFieldElement: ByteVectorType;
        KZGCommitment: ByteVectorType;
        KZGProof: ByteVectorType;
        Blob: ByteVectorType;
        Blobs: ListCompositeType<ByteVectorType>;
        BlindedBlob: ByteVectorType;
        BlindedBlobs: ListCompositeType<ByteVectorType>;
        VersionedHash: ByteVectorType;
        BlobKzgCommitments: ListCompositeType<ByteVectorType>;
        KZGProofs: ListCompositeType<ByteVectorType>;
        BlobSidecarsByRangeRequest: ContainerType<{
            startSlot: UintNumberType;
            count: UintNumberType;
        }>;
        BlobIdentifier: ContainerType<{
            blockRoot: ByteVectorType;
            index: UintNumberType;
        }>;
        KzgCommitmentInclusionProof: VectorCompositeType<ByteVectorType>;
        BlobSidecar: ContainerType<{
            index: UintNumberType;
            blob: ByteVectorType;
            kzgCommitment: ByteVectorType;
            kzgProof: ByteVectorType;
            signedBlockHeader: ContainerType<{
                message: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
            kzgCommitmentInclusionProof: VectorCompositeType<ByteVectorType>;
        }>;
        BlobSidecars: ListCompositeType<ContainerType<{
        index: UintNumberType;
        blob: ByteVectorType;
        kzgCommitment: ByteVectorType;
        kzgProof: ByteVectorType;
        signedBlockHeader: ContainerType<{
        message: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
        }>;
        signature: ByteVectorType;
        }>;
        kzgCommitmentInclusionProof: VectorCompositeType<ByteVectorType>;
        }>>;
        BlobsBundle: ContainerType<{
            commitments: ListCompositeType<ByteVectorType>;
            proofs: ListCompositeType<ByteVectorType>;
            blobs: ListCompositeType<ByteVectorType>;
        }>;
        ExecutionPayloadAndBlobsBundle: ContainerType<{
            executionPayload: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactions: ListCompositeType<ByteListType>;
                withdrawals: ListCompositeType<ContainerType<{
                index: UintNumberType;
                validatorIndex: UintNumberType;
                address: ExecutionAddressType;
                amount: UintBigintType;
                }>>;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            blobsBundle: ContainerType<{
                commitments: ListCompositeType<ByteVectorType>;
                proofs: ListCompositeType<ByteVectorType>;
                blobs: ListCompositeType<ByteVectorType>;
            }>;
        }>;
        LightClientHeader: ContainerType<{
            beacon: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            execution: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            executionBranch: VectorCompositeType<ByteVectorType>;
        }>;
        CurrentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
        FinalityBranch: VectorCompositeType<ByteVectorType>;
        NextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
        AggregationBits: BitListType;
        CommitteeBits: BitVectorType;
        AttestingIndices: ListBasicType<UintNumberType>;
        Attestation: ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
            committeeBits: BitVectorType;
        }>;
        SingleAttestation: ContainerType<{
            committeeIndex: UintNumberType;
            attesterIndex: UintNumberType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        IndexedAttestation: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        IndexedAttestationBigint: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        AttesterSlashing: ContainerType<{
            attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
        }>;
        AggregateAndProof: ContainerType<{
            aggregatorIndex: UintNumberType;
            aggregate: ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
                committeeBits: BitVectorType;
            }>;
            selectionProof: ByteVectorType;
        }>;
        SignedAggregateAndProof: ContainerType<{
            message: ContainerType<{
                aggregatorIndex: UintNumberType;
                aggregate: ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                        slot: UintNumberType;
                        index: UintNumberType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintNumberType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintNumberType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                    committeeBits: BitVectorType;
                }>;
                selectionProof: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        DepositRequest: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            index: UintBigintType;
        }>;
        DepositRequests: ListCompositeType<ContainerType<{
        pubkey: ByteVectorType;
        withdrawalCredentials: ByteVectorType;
        amount: UintNumberType;
        signature: ByteVectorType;
        index: UintBigintType;
        }>>;
        WithdrawalRequest: ContainerType<{
            sourceAddress: ExecutionAddressType;
            validatorPubkey: ByteVectorType;
            amount: UintBigintType;
        }>;
        WithdrawalRequests: ListCompositeType<ContainerType<{
        sourceAddress: ExecutionAddressType;
        validatorPubkey: ByteVectorType;
        amount: UintBigintType;
        }>>;
        ConsolidationRequest: ContainerType<{
            sourceAddress: ExecutionAddressType;
            sourcePubkey: ByteVectorType;
            targetPubkey: ByteVectorType;
        }>;
        ConsolidationRequests: ListCompositeType<ContainerType<{
        sourceAddress: ExecutionAddressType;
        sourcePubkey: ByteVectorType;
        targetPubkey: ByteVectorType;
        }>>;
        ExecutionRequests: ContainerType<{
            deposits: ListCompositeType<ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            index: UintBigintType;
            }>>;
            withdrawals: ListCompositeType<ContainerType<{
            sourceAddress: ExecutionAddressType;
            validatorPubkey: ByteVectorType;
            amount: UintBigintType;
            }>>;
            consolidations: ListCompositeType<ContainerType<{
            sourceAddress: ExecutionAddressType;
            sourcePubkey: ByteVectorType;
            targetPubkey: ByteVectorType;
            }>>;
        }>;
        ExecutionPayloadHeader: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
        }>;
        ExecutionPayload: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactions: ListCompositeType<ByteListType>;
            withdrawals: ListCompositeType<ContainerType<{
            index: UintNumberType;
            validatorIndex: UintNumberType;
            address: ExecutionAddressType;
            amount: UintBigintType;
            }>>;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
        }>;
        BeaconBlockBody: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
            signedHeader1: ContainerType<{
            message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
            message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
            }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
            attestation1: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            committeeBits: BitVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
            message: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
            }>>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            executionPayload: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactions: ListCompositeType<ByteListType>;
                withdrawals: ListCompositeType<ContainerType<{
                index: UintNumberType;
                validatorIndex: UintNumberType;
                address: ExecutionAddressType;
                amount: UintBigintType;
                }>>;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            blsToExecutionChanges: ListCompositeType<ContainerType<{
            message: ContainerType<{
            validatorIndex: UintNumberType;
            fromBlsPubkey: ByteVectorType;
            toExecutionAddress: ExecutionAddressType;
            }>;
            signature: ByteVectorType;
            }>>;
            blobKzgCommitments: ListCompositeType<ByteVectorType>;
            executionRequests: ContainerType<{
                deposits: ListCompositeType<ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                index: UintBigintType;
                }>>;
                withdrawals: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                validatorPubkey: ByteVectorType;
                amount: UintBigintType;
                }>>;
                consolidations: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                sourcePubkey: ByteVectorType;
                targetPubkey: ByteVectorType;
                }>>;
            }>;
        }>;
        BeaconBlock: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            body: ContainerType<{
                randaoReveal: ByteVectorType;
                eth1Data: ContainerType<{
                    depositRoot: ByteVectorType;
                    depositCount: UintNumberType;
                    blockHash: ByteVectorType;
                }>;
                graffiti: ByteVectorType;
                proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
                }>;
                }>>;
                attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>;
                }>>;
                attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                committeeBits: BitVectorType;
                }>>;
                deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                }>;
                }>>;
                voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
                }>>;
                syncAggregate: ContainerType<{
                    syncCommitteeBits: BitVectorType;
                    syncCommitteeSignature: ByteVectorType;
                }>;
                executionPayload: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactions: ListCompositeType<ByteListType>;
                    withdrawals: ListCompositeType<ContainerType<{
                    index: UintNumberType;
                    validatorIndex: UintNumberType;
                    address: ExecutionAddressType;
                    amount: UintBigintType;
                    }>>;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                blsToExecutionChanges: ListCompositeType<ContainerType<{
                message: ContainerType<{
                validatorIndex: UintNumberType;
                fromBlsPubkey: ByteVectorType;
                toExecutionAddress: ExecutionAddressType;
                }>;
                signature: ByteVectorType;
                }>>;
                blobKzgCommitments: ListCompositeType<ByteVectorType>;
                executionRequests: ContainerType<{
                    deposits: ListCompositeType<ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    index: UintBigintType;
                    }>>;
                    withdrawals: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    validatorPubkey: ByteVectorType;
                    amount: UintBigintType;
                    }>>;
                    consolidations: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    sourcePubkey: ByteVectorType;
                    targetPubkey: ByteVectorType;
                    }>>;
                }>;
            }>;
        }>;
        SignedBeaconBlock: ContainerType<{
            message: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                body: ContainerType<{
                    randaoReveal: ByteVectorType;
                    eth1Data: ContainerType<{
                        depositRoot: ByteVectorType;
                        depositCount: UintNumberType;
                        blockHash: ByteVectorType;
                    }>;
                    graffiti: ByteVectorType;
                    proposerSlashings: ListCompositeType<ContainerType<{
                    signedHeader1: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    signedHeader2: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attesterSlashings: ListCompositeType<ContainerType<{
                    attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attestations: ListCompositeType<ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    committeeBits: BitVectorType;
                    }>>;
                    deposits: ListCompositeType<ContainerType<{
                    proof: VectorCompositeType<ByteVectorType>;
                    data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    voluntaryExits: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    syncAggregate: ContainerType<{
                        syncCommitteeBits: BitVectorType;
                        syncCommitteeSignature: ByteVectorType;
                    }>;
                    executionPayload: ContainerType<{
                        parentHash: ByteVectorType;
                        feeRecipient: ExecutionAddressType;
                        stateRoot: ByteVectorType;
                        receiptsRoot: ByteVectorType;
                        logsBloom: ByteVectorType;
                        prevRandao: ByteVectorType;
                        blockNumber: UintNumberType;
                        gasLimit: UintNumberType;
                        gasUsed: UintNumberType;
                        timestamp: UintNumberType;
                        extraData: ByteListType;
                        baseFeePerGas: UintBigintType;
                        blockHash: ByteVectorType;
                        transactions: ListCompositeType<ByteListType>;
                        withdrawals: ListCompositeType<ContainerType<{
                        index: UintNumberType;
                        validatorIndex: UintNumberType;
                        address: ExecutionAddressType;
                        amount: UintBigintType;
                        }>>;
                        blobGasUsed: UintBigintType;
                        excessBlobGas: UintBigintType;
                    }>;
                    blsToExecutionChanges: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    validatorIndex: UintNumberType;
                    fromBlsPubkey: ByteVectorType;
                    toExecutionAddress: ExecutionAddressType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    blobKzgCommitments: ListCompositeType<ByteVectorType>;
                    executionRequests: ContainerType<{
                        deposits: ListCompositeType<ContainerType<{
                        pubkey: ByteVectorType;
                        withdrawalCredentials: ByteVectorType;
                        amount: UintNumberType;
                        signature: ByteVectorType;
                        index: UintBigintType;
                        }>>;
                        withdrawals: ListCompositeType<ContainerType<{
                        sourceAddress: ExecutionAddressType;
                        validatorPubkey: ByteVectorType;
                        amount: UintBigintType;
                        }>>;
                        consolidations: ListCompositeType<ContainerType<{
                        sourceAddress: ExecutionAddressType;
                        sourcePubkey: ByteVectorType;
                        targetPubkey: ByteVectorType;
                        }>>;
                    }>;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        BlindedBeaconBlockBody: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
            signedHeader1: ContainerType<{
            message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
            message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
            }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
            attestation1: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            committeeBits: BitVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
            message: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
            }>>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            executionPayloadHeader: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            blsToExecutionChanges: ListCompositeType<ContainerType<{
            message: ContainerType<{
            validatorIndex: UintNumberType;
            fromBlsPubkey: ByteVectorType;
            toExecutionAddress: ExecutionAddressType;
            }>;
            signature: ByteVectorType;
            }>>;
            blobKzgCommitments: ListCompositeType<ByteVectorType>;
            executionRequests: ContainerType<{
                deposits: ListCompositeType<ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                index: UintBigintType;
                }>>;
                withdrawals: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                validatorPubkey: ByteVectorType;
                amount: UintBigintType;
                }>>;
                consolidations: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                sourcePubkey: ByteVectorType;
                targetPubkey: ByteVectorType;
                }>>;
            }>;
        }>;
        BlindedBeaconBlock: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            body: ContainerType<{
                randaoReveal: ByteVectorType;
                eth1Data: ContainerType<{
                    depositRoot: ByteVectorType;
                    depositCount: UintNumberType;
                    blockHash: ByteVectorType;
                }>;
                graffiti: ByteVectorType;
                proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
                }>;
                }>>;
                attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>;
                }>>;
                attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                committeeBits: BitVectorType;
                }>>;
                deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                }>;
                }>>;
                voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
                }>>;
                syncAggregate: ContainerType<{
                    syncCommitteeBits: BitVectorType;
                    syncCommitteeSignature: ByteVectorType;
                }>;
                executionPayloadHeader: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                blsToExecutionChanges: ListCompositeType<ContainerType<{
                message: ContainerType<{
                validatorIndex: UintNumberType;
                fromBlsPubkey: ByteVectorType;
                toExecutionAddress: ExecutionAddressType;
                }>;
                signature: ByteVectorType;
                }>>;
                blobKzgCommitments: ListCompositeType<ByteVectorType>;
                executionRequests: ContainerType<{
                    deposits: ListCompositeType<ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    index: UintBigintType;
                    }>>;
                    withdrawals: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    validatorPubkey: ByteVectorType;
                    amount: UintBigintType;
                    }>>;
                    consolidations: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    sourcePubkey: ByteVectorType;
                    targetPubkey: ByteVectorType;
                    }>>;
                }>;
            }>;
        }>;
        SignedBlindedBeaconBlock: ContainerType<{
            message: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                body: ContainerType<{
                    randaoReveal: ByteVectorType;
                    eth1Data: ContainerType<{
                        depositRoot: ByteVectorType;
                        depositCount: UintNumberType;
                        blockHash: ByteVectorType;
                    }>;
                    graffiti: ByteVectorType;
                    proposerSlashings: ListCompositeType<ContainerType<{
                    signedHeader1: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    signedHeader2: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attesterSlashings: ListCompositeType<ContainerType<{
                    attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attestations: ListCompositeType<ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    committeeBits: BitVectorType;
                    }>>;
                    deposits: ListCompositeType<ContainerType<{
                    proof: VectorCompositeType<ByteVectorType>;
                    data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    voluntaryExits: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    syncAggregate: ContainerType<{
                        syncCommitteeBits: BitVectorType;
                        syncCommitteeSignature: ByteVectorType;
                    }>;
                    executionPayloadHeader: ContainerType<{
                        parentHash: ByteVectorType;
                        feeRecipient: ExecutionAddressType;
                        stateRoot: ByteVectorType;
                        receiptsRoot: ByteVectorType;
                        logsBloom: ByteVectorType;
                        prevRandao: ByteVectorType;
                        blockNumber: UintNumberType;
                        gasLimit: UintNumberType;
                        gasUsed: UintNumberType;
                        timestamp: UintNumberType;
                        extraData: ByteListType;
                        baseFeePerGas: UintBigintType;
                        blockHash: ByteVectorType;
                        transactionsRoot: ByteVectorType;
                        withdrawalsRoot: ByteVectorType;
                        blobGasUsed: UintBigintType;
                        excessBlobGas: UintBigintType;
                    }>;
                    blsToExecutionChanges: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    validatorIndex: UintNumberType;
                    fromBlsPubkey: ByteVectorType;
                    toExecutionAddress: ExecutionAddressType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    blobKzgCommitments: ListCompositeType<ByteVectorType>;
                    executionRequests: ContainerType<{
                        deposits: ListCompositeType<ContainerType<{
                        pubkey: ByteVectorType;
                        withdrawalCredentials: ByteVectorType;
                        amount: UintNumberType;
                        signature: ByteVectorType;
                        index: UintBigintType;
                        }>>;
                        withdrawals: ListCompositeType<ContainerType<{
                        sourceAddress: ExecutionAddressType;
                        validatorPubkey: ByteVectorType;
                        amount: UintBigintType;
                        }>>;
                        consolidations: ListCompositeType<ContainerType<{
                        sourceAddress: ExecutionAddressType;
                        sourcePubkey: ByteVectorType;
                        targetPubkey: ByteVectorType;
                        }>>;
                    }>;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        BuilderBid: ContainerType<{
            header: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            blobKzgCommitments: ListCompositeType<ByteVectorType>;
            executionRequests: ContainerType<{
                deposits: ListCompositeType<ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                index: UintBigintType;
                }>>;
                withdrawals: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                validatorPubkey: ByteVectorType;
                amount: UintBigintType;
                }>>;
                consolidations: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                sourcePubkey: ByteVectorType;
                targetPubkey: ByteVectorType;
                }>>;
            }>;
            value: UintBigintType;
            pubkey: ByteVectorType;
        }>;
        SignedBuilderBid: ContainerType<{
            message: ContainerType<{
                header: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                blobKzgCommitments: ListCompositeType<ByteVectorType>;
                executionRequests: ContainerType<{
                    deposits: ListCompositeType<ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    index: UintBigintType;
                    }>>;
                    withdrawals: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    validatorPubkey: ByteVectorType;
                    amount: UintBigintType;
                    }>>;
                    consolidations: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    sourcePubkey: ByteVectorType;
                    targetPubkey: ByteVectorType;
                    }>>;
                }>;
                value: UintBigintType;
                pubkey: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        PendingDeposit: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            slot: UintNumberType;
        }>;
        PendingDeposits: ListCompositeType<ContainerType<{
        pubkey: ByteVectorType;
        withdrawalCredentials: ByteVectorType;
        amount: UintNumberType;
        signature: ByteVectorType;
        slot: UintNumberType;
        }>>;
        PendingPartialWithdrawal: ContainerType<{
            validatorIndex: UintNumberType;
            amount: UintBigintType;
            withdrawableEpoch: UintNumberType;
        }>;
        PendingPartialWithdrawals: ListCompositeType<ContainerType<{
        validatorIndex: UintNumberType;
        amount: UintBigintType;
        withdrawableEpoch: UintNumberType;
        }>>;
        PendingConsolidation: ContainerType<{
            sourceIndex: UintNumberType;
            targetIndex: UintNumberType;
        }>;
        PendingConsolidations: ListCompositeType<ContainerType<{
        sourceIndex: UintNumberType;
        targetIndex: UintNumberType;
        }>>;
        BeaconState: ContainerType<{
            genesisTime: UintNumberType;
            genesisValidatorsRoot: ByteVectorType;
            slot: UintNumberType;
            fork: ContainerType<{
                previousVersion: ByteVectorType;
                currentVersion: ByteVectorType;
                epoch: UintNumberType;
            }>;
            latestBlockHeader: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            blockRoots: VectorCompositeType<ByteVectorType>;
            stateRoots: VectorCompositeType<ByteVectorType>;
            historicalRoots: ListCompositeType<ByteVectorType>;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            eth1DataVotes: ListCompositeType<ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
            }>>;
            eth1DepositIndex: UintNumberType;
            validators: ListCompositeType<ValidatorNodeStructType>;
            balances: ListUintNum64Type;
            randaoMixes: VectorCompositeType<ByteVectorType>;
            slashings: VectorBasicType<UintNumberType>;
            previousEpochParticipation: ListBasicType<UintNumberType>;
            currentEpochParticipation: ListBasicType<UintNumberType>;
            justificationBits: BitVectorType;
            previousJustifiedCheckpoint: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            currentJustifiedCheckpoint: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            finalizedCheckpoint: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            inactivityScores: ListBasicType<UintNumberType>;
            currentSyncCommittee: ContainerType<{
                pubkeys: VectorCompositeType<ByteVectorType>;
                aggregatePubkey: ByteVectorType;
            }>;
            nextSyncCommittee: ContainerType<{
                pubkeys: VectorCompositeType<ByteVectorType>;
                aggregatePubkey: ByteVectorType;
            }>;
            latestExecutionPayloadHeader: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            nextWithdrawalIndex: UintNumberType;
            nextWithdrawalValidatorIndex: UintNumberType;
            historicalSummaries: ListCompositeType<ContainerType<{
            blockSummaryRoot: ByteVectorType;
            stateSummaryRoot: ByteVectorType;
            }>>;
            depositRequestsStartIndex: UintBigintType;
            depositBalanceToConsume: UintBigintType;
            exitBalanceToConsume: UintBigintType;
            earliestExitEpoch: UintNumberType;
            consolidationBalanceToConsume: UintBigintType;
            earliestConsolidationEpoch: UintNumberType;
            pendingDeposits: ListCompositeType<ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            slot: UintNumberType;
            }>>;
            pendingPartialWithdrawals: ListCompositeType<ContainerType<{
            validatorIndex: UintNumberType;
            amount: UintBigintType;
            withdrawableEpoch: UintNumberType;
            }>>;
            pendingConsolidations: ListCompositeType<ContainerType<{
            sourceIndex: UintNumberType;
            targetIndex: UintNumberType;
            }>>;
        }>;
        LightClientBootstrap: ContainerType<{
            header: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            currentSyncCommittee: ContainerType<{
                pubkeys: VectorCompositeType<ByteVectorType>;
                aggregatePubkey: ByteVectorType;
            }>;
            currentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
        }>;
        LightClientUpdate: ContainerType<{
            attestedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            nextSyncCommittee: ContainerType<{
                pubkeys: VectorCompositeType<ByteVectorType>;
                aggregatePubkey: ByteVectorType;
            }>;
            nextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
            finalizedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            finalityBranch: VectorCompositeType<ByteVectorType>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            signatureSlot: UintNumberType;
        }>;
        LightClientFinalityUpdate: ContainerType<{
            attestedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            finalizedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            finalityBranch: VectorCompositeType<ByteVectorType>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            signatureSlot: UintNumberType;
        }>;
        LightClientOptimisticUpdate: ContainerType<{
            attestedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            signatureSlot: UintNumberType;
        }>;
        LightClientStore: ContainerType<{
            snapshot: ContainerType<{
                header: ContainerType<{
                    beacon: ContainerType<{
                        slot: UintNumberType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    execution: ContainerType<{
                        parentHash: ByteVectorType;
                        feeRecipient: ExecutionAddressType;
                        stateRoot: ByteVectorType;
                        receiptsRoot: ByteVectorType;
                        logsBloom: ByteVectorType;
                        prevRandao: ByteVectorType;
                        blockNumber: UintNumberType;
                        gasLimit: UintNumberType;
                        gasUsed: UintNumberType;
                        timestamp: UintNumberType;
                        extraData: ByteListType;
                        baseFeePerGas: UintBigintType;
                        blockHash: ByteVectorType;
                        transactionsRoot: ByteVectorType;
                        withdrawalsRoot: ByteVectorType;
                        blobGasUsed: UintBigintType;
                        excessBlobGas: UintBigintType;
                    }>;
                    executionBranch: VectorCompositeType<ByteVectorType>;
                }>;
                currentSyncCommittee: ContainerType<{
                    pubkeys: VectorCompositeType<ByteVectorType>;
                    aggregatePubkey: ByteVectorType;
                }>;
                currentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
            }>;
            validUpdates: ListCompositeType<ContainerType<{
            attestedHeader: ContainerType<{
            beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            execution: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
            }>;
            executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            nextSyncCommittee: ContainerType<{
            pubkeys: VectorCompositeType<ByteVectorType>;
            aggregatePubkey: ByteVectorType;
            }>;
            nextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
            finalizedHeader: ContainerType<{
            beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            execution: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
            }>;
            executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            finalityBranch: VectorCompositeType<ByteVectorType>;
            syncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
            }>;
            signatureSlot: UintNumberType;
            }>>;
        }>;
        PayloadAttributes: ContainerType<{
            timestamp: UintNumberType;
            prevRandao: ByteVectorType;
            suggestedFeeRecipient: StringType<string>;
            withdrawals: ListCompositeType<ContainerType<{
            index: UintNumberType;
            validatorIndex: UintNumberType;
            address: ExecutionAddressType;
            amount: UintBigintType;
            }>>;
            parentBeaconBlockRoot: ByteVectorType;
        }>;
        SSEPayloadAttributes: ContainerType<{
            proposerIndex: UintNumberType;
            proposalSlot: UintNumberType;
            parentBlockNumber: UintNumberType;
            parentBlockRoot: ByteVectorType;
            parentBlockHash: ByteVectorType;
            payloadAttributes: ContainerType<{
                timestamp: UintNumberType;
                prevRandao: ByteVectorType;
                suggestedFeeRecipient: StringType<string>;
                withdrawals: ListCompositeType<ContainerType<{
                index: UintNumberType;
                validatorIndex: UintNumberType;
                address: ExecutionAddressType;
                amount: UintBigintType;
                }>>;
                parentBeaconBlockRoot: ByteVectorType;
            }>;
        }>;
        BlockContents: ContainerType<{
            block: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                body: ContainerType<{
                    randaoReveal: ByteVectorType;
                    eth1Data: ContainerType<{
                        depositRoot: ByteVectorType;
                        depositCount: UintNumberType;
                        blockHash: ByteVectorType;
                    }>;
                    graffiti: ByteVectorType;
                    proposerSlashings: ListCompositeType<ContainerType<{
                    signedHeader1: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    signedHeader2: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attesterSlashings: ListCompositeType<ContainerType<{
                    attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attestations: ListCompositeType<ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    committeeBits: BitVectorType;
                    }>>;
                    deposits: ListCompositeType<ContainerType<{
                    proof: VectorCompositeType<ByteVectorType>;
                    data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    voluntaryExits: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    syncAggregate: ContainerType<{
                        syncCommitteeBits: BitVectorType;
                        syncCommitteeSignature: ByteVectorType;
                    }>;
                    executionPayload: ContainerType<{
                        parentHash: ByteVectorType;
                        feeRecipient: ExecutionAddressType;
                        stateRoot: ByteVectorType;
                        receiptsRoot: ByteVectorType;
                        logsBloom: ByteVectorType;
                        prevRandao: ByteVectorType;
                        blockNumber: UintNumberType;
                        gasLimit: UintNumberType;
                        gasUsed: UintNumberType;
                        timestamp: UintNumberType;
                        extraData: ByteListType;
                        baseFeePerGas: UintBigintType;
                        blockHash: ByteVectorType;
                        transactions: ListCompositeType<ByteListType>;
                        withdrawals: ListCompositeType<ContainerType<{
                        index: UintNumberType;
                        validatorIndex: UintNumberType;
                        address: ExecutionAddressType;
                        amount: UintBigintType;
                        }>>;
                        blobGasUsed: UintBigintType;
                        excessBlobGas: UintBigintType;
                    }>;
                    blsToExecutionChanges: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    validatorIndex: UintNumberType;
                    fromBlsPubkey: ByteVectorType;
                    toExecutionAddress: ExecutionAddressType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    blobKzgCommitments: ListCompositeType<ByteVectorType>;
                    executionRequests: ContainerType<{
                        deposits: ListCompositeType<ContainerType<{
                        pubkey: ByteVectorType;
                        withdrawalCredentials: ByteVectorType;
                        amount: UintNumberType;
                        signature: ByteVectorType;
                        index: UintBigintType;
                        }>>;
                        withdrawals: ListCompositeType<ContainerType<{
                        sourceAddress: ExecutionAddressType;
                        validatorPubkey: ByteVectorType;
                        amount: UintBigintType;
                        }>>;
                        consolidations: ListCompositeType<ContainerType<{
                        sourceAddress: ExecutionAddressType;
                        sourcePubkey: ByteVectorType;
                        targetPubkey: ByteVectorType;
                        }>>;
                    }>;
                }>;
            }>;
            kzgProofs: ListCompositeType<ByteVectorType>;
            blobs: ListCompositeType<ByteVectorType>;
        }>;
        SignedBlockContents: ContainerType<{
            signedBlock: ContainerType<{
                message: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    body: ContainerType<{
                        randaoReveal: ByteVectorType;
                        eth1Data: ContainerType<{
                            depositRoot: ByteVectorType;
                            depositCount: UintNumberType;
                            blockHash: ByteVectorType;
                        }>;
                        graffiti: ByteVectorType;
                        proposerSlashings: ListCompositeType<ContainerType<{
                        signedHeader1: ContainerType<{
                        message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                        }>;
                        signature: ByteVectorType;
                        }>;
                        signedHeader2: ContainerType<{
                        message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                        }>;
                        signature: ByteVectorType;
                        }>;
                        }>>;
                        attesterSlashings: ListCompositeType<ContainerType<{
                        attestation1: ContainerType<{
                        attestingIndices: ListBasicType<UintNumberType>;
                        data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                        }>;
                        }>;
                        signature: ByteVectorType;
                        }>;
                        attestation2: ContainerType<{
                        attestingIndices: ListBasicType<UintNumberType>;
                        data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                        }>;
                        }>;
                        signature: ByteVectorType;
                        }>;
                        }>>;
                        attestations: ListCompositeType<ContainerType<{
                        aggregationBits: BitListType;
                        data: ContainerType<{
                        slot: UintNumberType;
                        index: UintNumberType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                        }>;
                        }>;
                        signature: ByteVectorType;
                        committeeBits: BitVectorType;
                        }>>;
                        deposits: ListCompositeType<ContainerType<{
                        proof: VectorCompositeType<ByteVectorType>;
                        data: ContainerType<{
                        pubkey: ByteVectorType;
                        withdrawalCredentials: ByteVectorType;
                        amount: UintNumberType;
                        signature: ByteVectorType;
                        }>;
                        }>>;
                        voluntaryExits: ListCompositeType<ContainerType<{
                        message: ContainerType<{
                        epoch: UintNumberType;
                        validatorIndex: UintNumberType;
                        }>;
                        signature: ByteVectorType;
                        }>>;
                        syncAggregate: ContainerType<{
                            syncCommitteeBits: BitVectorType;
                            syncCommitteeSignature: ByteVectorType;
                        }>;
                        executionPayload: ContainerType<{
                            parentHash: ByteVectorType;
                            feeRecipient: ExecutionAddressType;
                            stateRoot: ByteVectorType;
                            receiptsRoot: ByteVectorType;
                            logsBloom: ByteVectorType;
                            prevRandao: ByteVectorType;
                            blockNumber: UintNumberType;
                            gasLimit: UintNumberType;
                            gasUsed: UintNumberType;
                            timestamp: UintNumberType;
                            extraData: ByteListType;
                            baseFeePerGas: UintBigintType;
                            blockHash: ByteVectorType;
                            transactions: ListCompositeType<ByteListType>;
                            withdrawals: ListCompositeType<ContainerType<{
                            index: UintNumberType;
                            validatorIndex: UintNumberType;
                            address: ExecutionAddressType;
                            amount: UintBigintType;
                            }>>;
                            blobGasUsed: UintBigintType;
                            excessBlobGas: UintBigintType;
                        }>;
                        blsToExecutionChanges: ListCompositeType<ContainerType<{
                        message: ContainerType<{
                        validatorIndex: UintNumberType;
                        fromBlsPubkey: ByteVectorType;
                        toExecutionAddress: ExecutionAddressType;
                        }>;
                        signature: ByteVectorType;
                        }>>;
                        blobKzgCommitments: ListCompositeType<ByteVectorType>;
                        executionRequests: ContainerType<{
                            deposits: ListCompositeType<ContainerType<{
                            pubkey: ByteVectorType;
                            withdrawalCredentials: ByteVectorType;
                            amount: UintNumberType;
                            signature: ByteVectorType;
                            index: UintBigintType;
                            }>>;
                            withdrawals: ListCompositeType<ContainerType<{
                            sourceAddress: ExecutionAddressType;
                            validatorPubkey: ByteVectorType;
                            amount: UintBigintType;
                            }>>;
                            consolidations: ListCompositeType<ContainerType<{
                            sourceAddress: ExecutionAddressType;
                            sourcePubkey: ByteVectorType;
                            targetPubkey: ByteVectorType;
                            }>>;
                        }>;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            kzgProofs: ListCompositeType<ByteVectorType>;
            blobs: ListCompositeType<ByteVectorType>;
        }>;
    };
    fulu: {
        AttestationSubnets: BitVectorType;
        BeaconBlockHeader: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        BeaconBlockHeaderBigint: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        SignedBeaconBlockHeader: ContainerType<{
            message: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        SignedBeaconBlockHeaderBigint: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        Checkpoint: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
        }>;
        CheckpointBigint: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
        }>;
        CommitteeIndices: ListBasicType<UintNumberType>;
        DepositMessage: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
        }>;
        DepositData: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
        }>;
        DepositDataRootList: ListCompositeType<ByteVectorType>;
        DepositEvent: ContainerType<{
            depositData: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
            }>;
            blockNumber: UintNumberType;
            index: UintNumberType;
        }>;
        Eth1Data: ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
        }>;
        Eth1DataVotes: ListCompositeType<ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
        }>>;
        Eth1DataOrdered: ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
            blockNumber: UintNumberType;
        }>;
        Eth1Block: ContainerType<{
            timestamp: UintNumberType;
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
        }>;
        Fork: ContainerType<{
            previousVersion: ByteVectorType;
            currentVersion: ByteVectorType;
            epoch: UintNumberType;
        }>;
        ForkData: ContainerType<{
            currentVersion: ByteVectorType;
            genesisValidatorsRoot: ByteVectorType;
        }>;
        ENRForkID: ContainerType<{
            forkDigest: ByteVectorType;
            nextForkVersion: ByteVectorType;
            nextForkEpoch: UintNumberType;
        }>;
        HistoricalBlockRoots: VectorCompositeType<ByteVectorType>;
        HistoricalStateRoots: VectorCompositeType<ByteVectorType>;
        HistoricalBatch: ContainerType<{
            blockRoots: VectorCompositeType<ByteVectorType>;
            stateRoots: VectorCompositeType<ByteVectorType>;
        }>;
        HistoricalBatchRoots: ContainerType<{
            blockRoots: ByteVectorType;
            stateRoots: ByteVectorType;
        }>;
        Validator: ValidatorNodeStructType;
        Validators: ListCompositeType<ValidatorNodeStructType>;
        Balances: ListUintNum64Type;
        RandaoMixes: VectorCompositeType<ByteVectorType>;
        Slashings: VectorBasicType<UintNumberType>;
        JustificationBits: BitVectorType;
        AttestationData: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
        }>;
        AttestationDataBigint: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
            }>;
        }>;
        PendingAttestation: ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            inclusionDelay: UintNumberType;
            proposerIndex: UintNumberType;
        }>;
        SigningData: ContainerType<{
            objectRoot: ByteVectorType;
            domain: ByteVectorType;
        }>;
        Deposit: ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
            }>;
        }>;
        ProposerSlashing: ContainerType<{
            signedHeader1: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
        }>;
        VoluntaryExit: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
        }>;
        SignedVoluntaryExit: ContainerType<{
            message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
        }>;
        EpochAttestations: ListCompositeType<ContainerType<{
        aggregationBits: BitListType;
        data: ContainerType<{
        slot: UintNumberType;
        index: UintNumberType;
        beaconBlockRoot: ByteVectorType;
        source: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
        }>;
        target: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
        }>;
        }>;
        inclusionDelay: UintNumberType;
        proposerIndex: UintNumberType;
        }>>;
        CommitteeAssignment: ContainerType<{
            validators: ListBasicType<UintNumberType>;
            committeeIndex: UintNumberType;
            slot: UintNumberType;
        }>;
        Goodbye: UintBigintType;
        Ping: UintBigintType;
        BeaconBlocksByRangeRequest: ContainerType<{
            startSlot: UintNumberType;
            count: UintNumberType;
            step: UintNumberType;
        }>;
        Genesis: ContainerType<{
            genesisValidatorsRoot: ByteVectorType;
            genesisTime: UintNumberType;
            genesisForkVersion: ByteVectorType;
        }>;
        SyncSubnets: BitVectorType;
        SyncCommittee: ContainerType<{
            pubkeys: VectorCompositeType<ByteVectorType>;
            aggregatePubkey: ByteVectorType;
        }>;
        SyncCommitteeMessage: ContainerType<{
            slot: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            validatorIndex: UintNumberType;
            signature: ByteVectorType;
        }>;
        SyncCommitteeContribution: ContainerType<{
            slot: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            subcommitteeIndex: UintNumberType;
            aggregationBits: BitVectorType;
            signature: ByteVectorType;
        }>;
        ContributionAndProof: ContainerType<{
            aggregatorIndex: UintNumberType;
            contribution: ContainerType<{
                slot: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                subcommitteeIndex: UintNumberType;
                aggregationBits: BitVectorType;
                signature: ByteVectorType;
            }>;
            selectionProof: ByteVectorType;
        }>;
        SignedContributionAndProof: ContainerType<{
            message: ContainerType<{
                aggregatorIndex: UintNumberType;
                contribution: ContainerType<{
                    slot: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    subcommitteeIndex: UintNumberType;
                    aggregationBits: BitVectorType;
                    signature: ByteVectorType;
                }>;
                selectionProof: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        SyncAggregatorSelectionData: ContainerType<{
            slot: UintNumberType;
            subcommitteeIndex: UintNumberType;
        }>;
        SyncCommitteeBits: BitVectorType;
        SyncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
        }>;
        EpochParticipation: ListBasicType<UintNumberType>;
        InactivityScores: ListBasicType<UintNumberType>;
        LightClientUpdatesByRange: ContainerType<{
            startPeriod: UintNumberType;
            count: UintNumberType;
        }>;
        Transaction: ByteListType;
        Transactions: ListCompositeType<ByteListType>;
        CommonExecutionPayloadType: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
        }>;
        PowBlock: ContainerType<{
            blockHash: ByteVectorType;
            parentHash: ByteVectorType;
            totalDifficulty: UintBigintType;
        }>;
        ValidatorRegistrationV1: ContainerType<{
            feeRecipient: ExecutionAddressType;
            gasLimit: UintNumberType;
            timestamp: UintNumberType;
            pubkey: ByteVectorType;
        }>;
        SignedValidatorRegistrationV1: ContainerType<{
            message: ContainerType<{
                feeRecipient: ExecutionAddressType;
                gasLimit: UintNumberType;
                timestamp: UintNumberType;
                pubkey: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        SSEPayloadAttributesCommon: ContainerType<{
            proposerIndex: UintNumberType;
            proposalSlot: UintNumberType;
            parentBlockNumber: UintNumberType;
            parentBlockRoot: ByteVectorType;
            parentBlockHash: ByteVectorType;
        }>;
        ExecutionBranch: VectorCompositeType<ByteVectorType>;
        Withdrawal: ContainerType<{
            index: UintNumberType;
            validatorIndex: UintNumberType;
            address: ExecutionAddressType;
            amount: UintBigintType;
        }>;
        BLSToExecutionChange: ContainerType<{
            validatorIndex: UintNumberType;
            fromBlsPubkey: ByteVectorType;
            toExecutionAddress: ExecutionAddressType;
        }>;
        SignedBLSToExecutionChange: ContainerType<{
            message: ContainerType<{
                validatorIndex: UintNumberType;
                fromBlsPubkey: ByteVectorType;
                toExecutionAddress: ExecutionAddressType;
            }>;
            signature: ByteVectorType;
        }>;
        Withdrawals: ListCompositeType<ContainerType<{
        index: UintNumberType;
        validatorIndex: UintNumberType;
        address: ExecutionAddressType;
        amount: UintBigintType;
        }>>;
        BLSToExecutionChanges: ListCompositeType<ContainerType<{
        message: ContainerType<{
        validatorIndex: UintNumberType;
        fromBlsPubkey: ByteVectorType;
        toExecutionAddress: ExecutionAddressType;
        }>;
        signature: ByteVectorType;
        }>>;
        HistoricalSummary: ContainerType<{
            blockSummaryRoot: ByteVectorType;
            stateSummaryRoot: ByteVectorType;
        }>;
        HistoricalSummaries: ListCompositeType<ContainerType<{
        blockSummaryRoot: ByteVectorType;
        stateSummaryRoot: ByteVectorType;
        }>>;
        G1Point: ByteVectorType;
        G2Point: ByteVectorType;
        BLSFieldElement: ByteVectorType;
        KZGCommitment: ByteVectorType;
        Blobs: ListCompositeType<ByteVectorType>;
        BlindedBlob: ByteVectorType;
        BlindedBlobs: ListCompositeType<ByteVectorType>;
        VersionedHash: ByteVectorType;
        BlobKzgCommitments: ListCompositeType<ByteVectorType>;
        BlobSidecarsByRangeRequest: ContainerType<{
            startSlot: UintNumberType;
            count: UintNumberType;
        }>;
        BlobIdentifier: ContainerType<{
            blockRoot: ByteVectorType;
            index: UintNumberType;
        }>;
        KzgCommitmentInclusionProof: VectorCompositeType<ByteVectorType>;
        BlobSidecar: ContainerType<{
            index: UintNumberType;
            blob: ByteVectorType;
            kzgCommitment: ByteVectorType;
            kzgProof: ByteVectorType;
            signedBlockHeader: ContainerType<{
                message: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
            kzgCommitmentInclusionProof: VectorCompositeType<ByteVectorType>;
        }>;
        BlobSidecars: ListCompositeType<ContainerType<{
        index: UintNumberType;
        blob: ByteVectorType;
        kzgCommitment: ByteVectorType;
        kzgProof: ByteVectorType;
        signedBlockHeader: ContainerType<{
        message: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
        }>;
        signature: ByteVectorType;
        }>;
        kzgCommitmentInclusionProof: VectorCompositeType<ByteVectorType>;
        }>>;
        LightClientHeader: ContainerType<{
            beacon: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            execution: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            executionBranch: VectorCompositeType<ByteVectorType>;
        }>;
        CurrentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
        FinalityBranch: VectorCompositeType<ByteVectorType>;
        NextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
        AggregationBits: BitListType;
        CommitteeBits: BitVectorType;
        AttestingIndices: ListBasicType<UintNumberType>;
        Attestation: ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
            committeeBits: BitVectorType;
        }>;
        SingleAttestation: ContainerType<{
            committeeIndex: UintNumberType;
            attesterIndex: UintNumberType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        IndexedAttestation: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        IndexedAttestationBigint: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        AttesterSlashing: ContainerType<{
            attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
        }>;
        AggregateAndProof: ContainerType<{
            aggregatorIndex: UintNumberType;
            aggregate: ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
                committeeBits: BitVectorType;
            }>;
            selectionProof: ByteVectorType;
        }>;
        SignedAggregateAndProof: ContainerType<{
            message: ContainerType<{
                aggregatorIndex: UintNumberType;
                aggregate: ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                        slot: UintNumberType;
                        index: UintNumberType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintNumberType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintNumberType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                    committeeBits: BitVectorType;
                }>;
                selectionProof: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        DepositRequest: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            index: UintBigintType;
        }>;
        DepositRequests: ListCompositeType<ContainerType<{
        pubkey: ByteVectorType;
        withdrawalCredentials: ByteVectorType;
        amount: UintNumberType;
        signature: ByteVectorType;
        index: UintBigintType;
        }>>;
        WithdrawalRequest: ContainerType<{
            sourceAddress: ExecutionAddressType;
            validatorPubkey: ByteVectorType;
            amount: UintBigintType;
        }>;
        WithdrawalRequests: ListCompositeType<ContainerType<{
        sourceAddress: ExecutionAddressType;
        validatorPubkey: ByteVectorType;
        amount: UintBigintType;
        }>>;
        ConsolidationRequest: ContainerType<{
            sourceAddress: ExecutionAddressType;
            sourcePubkey: ByteVectorType;
            targetPubkey: ByteVectorType;
        }>;
        ConsolidationRequests: ListCompositeType<ContainerType<{
        sourceAddress: ExecutionAddressType;
        sourcePubkey: ByteVectorType;
        targetPubkey: ByteVectorType;
        }>>;
        ExecutionRequests: ContainerType<{
            deposits: ListCompositeType<ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            index: UintBigintType;
            }>>;
            withdrawals: ListCompositeType<ContainerType<{
            sourceAddress: ExecutionAddressType;
            validatorPubkey: ByteVectorType;
            amount: UintBigintType;
            }>>;
            consolidations: ListCompositeType<ContainerType<{
            sourceAddress: ExecutionAddressType;
            sourcePubkey: ByteVectorType;
            targetPubkey: ByteVectorType;
            }>>;
        }>;
        ExecutionPayloadHeader: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
        }>;
        ExecutionPayload: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactions: ListCompositeType<ByteListType>;
            withdrawals: ListCompositeType<ContainerType<{
            index: UintNumberType;
            validatorIndex: UintNumberType;
            address: ExecutionAddressType;
            amount: UintBigintType;
            }>>;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
        }>;
        BeaconBlockBody: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
            signedHeader1: ContainerType<{
            message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
            message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
            }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
            attestation1: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            committeeBits: BitVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
            message: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
            }>>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            executionPayload: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactions: ListCompositeType<ByteListType>;
                withdrawals: ListCompositeType<ContainerType<{
                index: UintNumberType;
                validatorIndex: UintNumberType;
                address: ExecutionAddressType;
                amount: UintBigintType;
                }>>;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            blsToExecutionChanges: ListCompositeType<ContainerType<{
            message: ContainerType<{
            validatorIndex: UintNumberType;
            fromBlsPubkey: ByteVectorType;
            toExecutionAddress: ExecutionAddressType;
            }>;
            signature: ByteVectorType;
            }>>;
            blobKzgCommitments: ListCompositeType<ByteVectorType>;
            executionRequests: ContainerType<{
                deposits: ListCompositeType<ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                index: UintBigintType;
                }>>;
                withdrawals: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                validatorPubkey: ByteVectorType;
                amount: UintBigintType;
                }>>;
                consolidations: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                sourcePubkey: ByteVectorType;
                targetPubkey: ByteVectorType;
                }>>;
            }>;
        }>;
        BlindedBeaconBlockBody: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
            signedHeader1: ContainerType<{
            message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
            message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
            }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
            attestation1: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            committeeBits: BitVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
            message: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
            }>>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            executionPayloadHeader: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            blsToExecutionChanges: ListCompositeType<ContainerType<{
            message: ContainerType<{
            validatorIndex: UintNumberType;
            fromBlsPubkey: ByteVectorType;
            toExecutionAddress: ExecutionAddressType;
            }>;
            signature: ByteVectorType;
            }>>;
            blobKzgCommitments: ListCompositeType<ByteVectorType>;
            executionRequests: ContainerType<{
                deposits: ListCompositeType<ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                index: UintBigintType;
                }>>;
                withdrawals: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                validatorPubkey: ByteVectorType;
                amount: UintBigintType;
                }>>;
                consolidations: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                sourcePubkey: ByteVectorType;
                targetPubkey: ByteVectorType;
                }>>;
            }>;
        }>;
        BlindedBeaconBlock: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            body: ContainerType<{
                randaoReveal: ByteVectorType;
                eth1Data: ContainerType<{
                    depositRoot: ByteVectorType;
                    depositCount: UintNumberType;
                    blockHash: ByteVectorType;
                }>;
                graffiti: ByteVectorType;
                proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
                }>;
                }>>;
                attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>;
                }>>;
                attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                committeeBits: BitVectorType;
                }>>;
                deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                }>;
                }>>;
                voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
                }>>;
                syncAggregate: ContainerType<{
                    syncCommitteeBits: BitVectorType;
                    syncCommitteeSignature: ByteVectorType;
                }>;
                executionPayloadHeader: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                blsToExecutionChanges: ListCompositeType<ContainerType<{
                message: ContainerType<{
                validatorIndex: UintNumberType;
                fromBlsPubkey: ByteVectorType;
                toExecutionAddress: ExecutionAddressType;
                }>;
                signature: ByteVectorType;
                }>>;
                blobKzgCommitments: ListCompositeType<ByteVectorType>;
                executionRequests: ContainerType<{
                    deposits: ListCompositeType<ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    index: UintBigintType;
                    }>>;
                    withdrawals: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    validatorPubkey: ByteVectorType;
                    amount: UintBigintType;
                    }>>;
                    consolidations: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    sourcePubkey: ByteVectorType;
                    targetPubkey: ByteVectorType;
                    }>>;
                }>;
            }>;
        }>;
        SignedBlindedBeaconBlock: ContainerType<{
            message: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                body: ContainerType<{
                    randaoReveal: ByteVectorType;
                    eth1Data: ContainerType<{
                        depositRoot: ByteVectorType;
                        depositCount: UintNumberType;
                        blockHash: ByteVectorType;
                    }>;
                    graffiti: ByteVectorType;
                    proposerSlashings: ListCompositeType<ContainerType<{
                    signedHeader1: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    signedHeader2: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attesterSlashings: ListCompositeType<ContainerType<{
                    attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attestations: ListCompositeType<ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    committeeBits: BitVectorType;
                    }>>;
                    deposits: ListCompositeType<ContainerType<{
                    proof: VectorCompositeType<ByteVectorType>;
                    data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    voluntaryExits: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    syncAggregate: ContainerType<{
                        syncCommitteeBits: BitVectorType;
                        syncCommitteeSignature: ByteVectorType;
                    }>;
                    executionPayloadHeader: ContainerType<{
                        parentHash: ByteVectorType;
                        feeRecipient: ExecutionAddressType;
                        stateRoot: ByteVectorType;
                        receiptsRoot: ByteVectorType;
                        logsBloom: ByteVectorType;
                        prevRandao: ByteVectorType;
                        blockNumber: UintNumberType;
                        gasLimit: UintNumberType;
                        gasUsed: UintNumberType;
                        timestamp: UintNumberType;
                        extraData: ByteListType;
                        baseFeePerGas: UintBigintType;
                        blockHash: ByteVectorType;
                        transactionsRoot: ByteVectorType;
                        withdrawalsRoot: ByteVectorType;
                        blobGasUsed: UintBigintType;
                        excessBlobGas: UintBigintType;
                    }>;
                    blsToExecutionChanges: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    validatorIndex: UintNumberType;
                    fromBlsPubkey: ByteVectorType;
                    toExecutionAddress: ExecutionAddressType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    blobKzgCommitments: ListCompositeType<ByteVectorType>;
                    executionRequests: ContainerType<{
                        deposits: ListCompositeType<ContainerType<{
                        pubkey: ByteVectorType;
                        withdrawalCredentials: ByteVectorType;
                        amount: UintNumberType;
                        signature: ByteVectorType;
                        index: UintBigintType;
                        }>>;
                        withdrawals: ListCompositeType<ContainerType<{
                        sourceAddress: ExecutionAddressType;
                        validatorPubkey: ByteVectorType;
                        amount: UintBigintType;
                        }>>;
                        consolidations: ListCompositeType<ContainerType<{
                        sourceAddress: ExecutionAddressType;
                        sourcePubkey: ByteVectorType;
                        targetPubkey: ByteVectorType;
                        }>>;
                    }>;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        BuilderBid: ContainerType<{
            header: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            blobKzgCommitments: ListCompositeType<ByteVectorType>;
            executionRequests: ContainerType<{
                deposits: ListCompositeType<ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                index: UintBigintType;
                }>>;
                withdrawals: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                validatorPubkey: ByteVectorType;
                amount: UintBigintType;
                }>>;
                consolidations: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                sourcePubkey: ByteVectorType;
                targetPubkey: ByteVectorType;
                }>>;
            }>;
            value: UintBigintType;
            pubkey: ByteVectorType;
        }>;
        SignedBuilderBid: ContainerType<{
            message: ContainerType<{
                header: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                blobKzgCommitments: ListCompositeType<ByteVectorType>;
                executionRequests: ContainerType<{
                    deposits: ListCompositeType<ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    index: UintBigintType;
                    }>>;
                    withdrawals: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    validatorPubkey: ByteVectorType;
                    amount: UintBigintType;
                    }>>;
                    consolidations: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    sourcePubkey: ByteVectorType;
                    targetPubkey: ByteVectorType;
                    }>>;
                }>;
                value: UintBigintType;
                pubkey: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        PendingDeposit: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            slot: UintNumberType;
        }>;
        PendingDeposits: ListCompositeType<ContainerType<{
        pubkey: ByteVectorType;
        withdrawalCredentials: ByteVectorType;
        amount: UintNumberType;
        signature: ByteVectorType;
        slot: UintNumberType;
        }>>;
        PendingPartialWithdrawal: ContainerType<{
            validatorIndex: UintNumberType;
            amount: UintBigintType;
            withdrawableEpoch: UintNumberType;
        }>;
        PendingPartialWithdrawals: ListCompositeType<ContainerType<{
        validatorIndex: UintNumberType;
        amount: UintBigintType;
        withdrawableEpoch: UintNumberType;
        }>>;
        PendingConsolidation: ContainerType<{
            sourceIndex: UintNumberType;
            targetIndex: UintNumberType;
        }>;
        PendingConsolidations: ListCompositeType<ContainerType<{
        sourceIndex: UintNumberType;
        targetIndex: UintNumberType;
        }>>;
        LightClientBootstrap: ContainerType<{
            header: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            currentSyncCommittee: ContainerType<{
                pubkeys: VectorCompositeType<ByteVectorType>;
                aggregatePubkey: ByteVectorType;
            }>;
            currentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
        }>;
        LightClientUpdate: ContainerType<{
            attestedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            nextSyncCommittee: ContainerType<{
                pubkeys: VectorCompositeType<ByteVectorType>;
                aggregatePubkey: ByteVectorType;
            }>;
            nextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
            finalizedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            finalityBranch: VectorCompositeType<ByteVectorType>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            signatureSlot: UintNumberType;
        }>;
        LightClientFinalityUpdate: ContainerType<{
            attestedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            finalizedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            finalityBranch: VectorCompositeType<ByteVectorType>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            signatureSlot: UintNumberType;
        }>;
        LightClientOptimisticUpdate: ContainerType<{
            attestedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            signatureSlot: UintNumberType;
        }>;
        LightClientStore: ContainerType<{
            snapshot: ContainerType<{
                header: ContainerType<{
                    beacon: ContainerType<{
                        slot: UintNumberType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    execution: ContainerType<{
                        parentHash: ByteVectorType;
                        feeRecipient: ExecutionAddressType;
                        stateRoot: ByteVectorType;
                        receiptsRoot: ByteVectorType;
                        logsBloom: ByteVectorType;
                        prevRandao: ByteVectorType;
                        blockNumber: UintNumberType;
                        gasLimit: UintNumberType;
                        gasUsed: UintNumberType;
                        timestamp: UintNumberType;
                        extraData: ByteListType;
                        baseFeePerGas: UintBigintType;
                        blockHash: ByteVectorType;
                        transactionsRoot: ByteVectorType;
                        withdrawalsRoot: ByteVectorType;
                        blobGasUsed: UintBigintType;
                        excessBlobGas: UintBigintType;
                    }>;
                    executionBranch: VectorCompositeType<ByteVectorType>;
                }>;
                currentSyncCommittee: ContainerType<{
                    pubkeys: VectorCompositeType<ByteVectorType>;
                    aggregatePubkey: ByteVectorType;
                }>;
                currentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
            }>;
            validUpdates: ListCompositeType<ContainerType<{
            attestedHeader: ContainerType<{
            beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            execution: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
            }>;
            executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            nextSyncCommittee: ContainerType<{
            pubkeys: VectorCompositeType<ByteVectorType>;
            aggregatePubkey: ByteVectorType;
            }>;
            nextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
            finalizedHeader: ContainerType<{
            beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            execution: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
            }>;
            executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            finalityBranch: VectorCompositeType<ByteVectorType>;
            syncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
            }>;
            signatureSlot: UintNumberType;
            }>>;
        }>;
        PayloadAttributes: ContainerType<{
            timestamp: UintNumberType;
            prevRandao: ByteVectorType;
            suggestedFeeRecipient: StringType<string>;
            withdrawals: ListCompositeType<ContainerType<{
            index: UintNumberType;
            validatorIndex: UintNumberType;
            address: ExecutionAddressType;
            amount: UintBigintType;
            }>>;
            parentBeaconBlockRoot: ByteVectorType;
        }>;
        SSEPayloadAttributes: ContainerType<{
            proposerIndex: UintNumberType;
            proposalSlot: UintNumberType;
            parentBlockNumber: UintNumberType;
            parentBlockRoot: ByteVectorType;
            parentBlockHash: ByteVectorType;
            payloadAttributes: ContainerType<{
                timestamp: UintNumberType;
                prevRandao: ByteVectorType;
                suggestedFeeRecipient: StringType<string>;
                withdrawals: ListCompositeType<ContainerType<{
                index: UintNumberType;
                validatorIndex: UintNumberType;
                address: ExecutionAddressType;
                amount: UintBigintType;
                }>>;
                parentBeaconBlockRoot: ByteVectorType;
            }>;
        }>;
        KZGProof: ByteVectorType;
        Blob: ByteVectorType;
        Metadata: ContainerType<{
            seqNumber: UintBigintType;
            attnets: BitVectorType;
            syncnets: BitVectorType;
            custodyGroupCount: UintNumberType;
        }>;
        Status: ContainerType<{
            forkDigest: ByteVectorType;
            finalizedRoot: ByteVectorType;
            finalizedEpoch: UintNumberType;
            headRoot: ByteVectorType;
            headSlot: UintNumberType;
            earliestAvailableSlot: UintNumberType;
        }>;
        Cell: ByteVectorType;
        DataColumn: ListCompositeType<ByteVectorType>;
        DataColumns: ListCompositeType<ListCompositeType<ByteVectorType>>;
        ExtendedMatrix: ListCompositeType<ByteVectorType>;
        KzgCommitmentsInclusionProof: VectorCompositeType<ByteVectorType>;
        KZGProofs: ListCompositeType<ByteVectorType>;
        ProposerLookahead: VectorBasicType<UintNumberType>;
        DataColumnSidecar: ContainerType<{
            index: UintNumberType;
            column: ListCompositeType<ByteVectorType>;
            kzgCommitments: ListCompositeType<ByteVectorType>;
            kzgProofs: ListCompositeType<ByteVectorType>;
            signedBlockHeader: ContainerType<{
                message: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
            kzgCommitmentsInclusionProof: VectorCompositeType<ByteVectorType>;
        }>;
        DataColumnSidecars: ListCompositeType<ContainerType<{
        index: UintNumberType;
        column: ListCompositeType<ByteVectorType>;
        kzgCommitments: ListCompositeType<ByteVectorType>;
        kzgProofs: ListCompositeType<ByteVectorType>;
        signedBlockHeader: ContainerType<{
        message: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
        }>;
        signature: ByteVectorType;
        }>;
        kzgCommitmentsInclusionProof: VectorCompositeType<ByteVectorType>;
        }>>;
        MatrixEntry: ContainerType<{
            cell: ByteVectorType;
            kzgProof: ByteVectorType;
            columnIndex: UintNumberType;
            rowIndex: UintNumberType;
        }>;
        DataColumnsByRootIdentifier: ContainerType<{
            blockRoot: ByteVectorType;
            columns: ListBasicType<UintNumberType>;
        }>;
        DataColumnSidecarsByRangeRequest: ContainerType<{
            startSlot: UintNumberType;
            count: UintNumberType;
            columns: ListBasicType<UintNumberType>;
        }>;
        BeaconBlocksByHeadRequest: ContainerType<{
            beaconRoot: ByteVectorType;
            count: UintNumberType;
        }>;
        BeaconBlock: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            body: ContainerType<{
                randaoReveal: ByteVectorType;
                eth1Data: ContainerType<{
                    depositRoot: ByteVectorType;
                    depositCount: UintNumberType;
                    blockHash: ByteVectorType;
                }>;
                graffiti: ByteVectorType;
                proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
                }>;
                }>>;
                attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>;
                }>>;
                attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                committeeBits: BitVectorType;
                }>>;
                deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                }>;
                }>>;
                voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
                }>>;
                syncAggregate: ContainerType<{
                    syncCommitteeBits: BitVectorType;
                    syncCommitteeSignature: ByteVectorType;
                }>;
                executionPayload: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactions: ListCompositeType<ByteListType>;
                    withdrawals: ListCompositeType<ContainerType<{
                    index: UintNumberType;
                    validatorIndex: UintNumberType;
                    address: ExecutionAddressType;
                    amount: UintBigintType;
                    }>>;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                blsToExecutionChanges: ListCompositeType<ContainerType<{
                message: ContainerType<{
                validatorIndex: UintNumberType;
                fromBlsPubkey: ByteVectorType;
                toExecutionAddress: ExecutionAddressType;
                }>;
                signature: ByteVectorType;
                }>>;
                blobKzgCommitments: ListCompositeType<ByteVectorType>;
                executionRequests: ContainerType<{
                    deposits: ListCompositeType<ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    index: UintBigintType;
                    }>>;
                    withdrawals: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    validatorPubkey: ByteVectorType;
                    amount: UintBigintType;
                    }>>;
                    consolidations: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    sourcePubkey: ByteVectorType;
                    targetPubkey: ByteVectorType;
                    }>>;
                }>;
            }>;
        }>;
        SignedBeaconBlock: ContainerType<{
            message: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                body: ContainerType<{
                    randaoReveal: ByteVectorType;
                    eth1Data: ContainerType<{
                        depositRoot: ByteVectorType;
                        depositCount: UintNumberType;
                        blockHash: ByteVectorType;
                    }>;
                    graffiti: ByteVectorType;
                    proposerSlashings: ListCompositeType<ContainerType<{
                    signedHeader1: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    signedHeader2: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attesterSlashings: ListCompositeType<ContainerType<{
                    attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attestations: ListCompositeType<ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    committeeBits: BitVectorType;
                    }>>;
                    deposits: ListCompositeType<ContainerType<{
                    proof: VectorCompositeType<ByteVectorType>;
                    data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    voluntaryExits: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    syncAggregate: ContainerType<{
                        syncCommitteeBits: BitVectorType;
                        syncCommitteeSignature: ByteVectorType;
                    }>;
                    executionPayload: ContainerType<{
                        parentHash: ByteVectorType;
                        feeRecipient: ExecutionAddressType;
                        stateRoot: ByteVectorType;
                        receiptsRoot: ByteVectorType;
                        logsBloom: ByteVectorType;
                        prevRandao: ByteVectorType;
                        blockNumber: UintNumberType;
                        gasLimit: UintNumberType;
                        gasUsed: UintNumberType;
                        timestamp: UintNumberType;
                        extraData: ByteListType;
                        baseFeePerGas: UintBigintType;
                        blockHash: ByteVectorType;
                        transactions: ListCompositeType<ByteListType>;
                        withdrawals: ListCompositeType<ContainerType<{
                        index: UintNumberType;
                        validatorIndex: UintNumberType;
                        address: ExecutionAddressType;
                        amount: UintBigintType;
                        }>>;
                        blobGasUsed: UintBigintType;
                        excessBlobGas: UintBigintType;
                    }>;
                    blsToExecutionChanges: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    validatorIndex: UintNumberType;
                    fromBlsPubkey: ByteVectorType;
                    toExecutionAddress: ExecutionAddressType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    blobKzgCommitments: ListCompositeType<ByteVectorType>;
                    executionRequests: ContainerType<{
                        deposits: ListCompositeType<ContainerType<{
                        pubkey: ByteVectorType;
                        withdrawalCredentials: ByteVectorType;
                        amount: UintNumberType;
                        signature: ByteVectorType;
                        index: UintBigintType;
                        }>>;
                        withdrawals: ListCompositeType<ContainerType<{
                        sourceAddress: ExecutionAddressType;
                        validatorPubkey: ByteVectorType;
                        amount: UintBigintType;
                        }>>;
                        consolidations: ListCompositeType<ContainerType<{
                        sourceAddress: ExecutionAddressType;
                        sourcePubkey: ByteVectorType;
                        targetPubkey: ByteVectorType;
                        }>>;
                    }>;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        BlobsBundle: ContainerType<{
            commitments: ListCompositeType<ByteVectorType>;
            proofs: ListCompositeType<ByteVectorType>;
            blobs: ListCompositeType<ByteVectorType>;
        }>;
        ExecutionPayloadAndBlobsBundle: ContainerType<{
            executionPayload: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactions: ListCompositeType<ByteListType>;
                withdrawals: ListCompositeType<ContainerType<{
                index: UintNumberType;
                validatorIndex: UintNumberType;
                address: ExecutionAddressType;
                amount: UintBigintType;
                }>>;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            blobsBundle: ContainerType<{
                commitments: ListCompositeType<ByteVectorType>;
                proofs: ListCompositeType<ByteVectorType>;
                blobs: ListCompositeType<ByteVectorType>;
            }>;
        }>;
        BeaconState: ContainerType<{
            genesisTime: UintNumberType;
            genesisValidatorsRoot: ByteVectorType;
            slot: UintNumberType;
            fork: ContainerType<{
                previousVersion: ByteVectorType;
                currentVersion: ByteVectorType;
                epoch: UintNumberType;
            }>;
            latestBlockHeader: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            blockRoots: VectorCompositeType<ByteVectorType>;
            stateRoots: VectorCompositeType<ByteVectorType>;
            historicalRoots: ListCompositeType<ByteVectorType>;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            eth1DataVotes: ListCompositeType<ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
            }>>;
            eth1DepositIndex: UintNumberType;
            validators: ListCompositeType<ValidatorNodeStructType>;
            balances: ListUintNum64Type;
            randaoMixes: VectorCompositeType<ByteVectorType>;
            slashings: VectorBasicType<UintNumberType>;
            previousEpochParticipation: ListBasicType<UintNumberType>;
            currentEpochParticipation: ListBasicType<UintNumberType>;
            justificationBits: BitVectorType;
            previousJustifiedCheckpoint: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            currentJustifiedCheckpoint: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            finalizedCheckpoint: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            inactivityScores: ListBasicType<UintNumberType>;
            currentSyncCommittee: ContainerType<{
                pubkeys: VectorCompositeType<ByteVectorType>;
                aggregatePubkey: ByteVectorType;
            }>;
            nextSyncCommittee: ContainerType<{
                pubkeys: VectorCompositeType<ByteVectorType>;
                aggregatePubkey: ByteVectorType;
            }>;
            latestExecutionPayloadHeader: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            nextWithdrawalIndex: UintNumberType;
            nextWithdrawalValidatorIndex: UintNumberType;
            historicalSummaries: ListCompositeType<ContainerType<{
            blockSummaryRoot: ByteVectorType;
            stateSummaryRoot: ByteVectorType;
            }>>;
            depositRequestsStartIndex: UintBigintType;
            depositBalanceToConsume: UintBigintType;
            exitBalanceToConsume: UintBigintType;
            earliestExitEpoch: UintNumberType;
            consolidationBalanceToConsume: UintBigintType;
            earliestConsolidationEpoch: UintNumberType;
            pendingDeposits: ListCompositeType<ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            slot: UintNumberType;
            }>>;
            pendingPartialWithdrawals: ListCompositeType<ContainerType<{
            validatorIndex: UintNumberType;
            amount: UintBigintType;
            withdrawableEpoch: UintNumberType;
            }>>;
            pendingConsolidations: ListCompositeType<ContainerType<{
            sourceIndex: UintNumberType;
            targetIndex: UintNumberType;
            }>>;
            proposerLookahead: VectorBasicType<UintNumberType>;
        }>;
        BlockContents: ContainerType<{
            block: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                body: ContainerType<{
                    randaoReveal: ByteVectorType;
                    eth1Data: ContainerType<{
                        depositRoot: ByteVectorType;
                        depositCount: UintNumberType;
                        blockHash: ByteVectorType;
                    }>;
                    graffiti: ByteVectorType;
                    proposerSlashings: ListCompositeType<ContainerType<{
                    signedHeader1: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    signedHeader2: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attesterSlashings: ListCompositeType<ContainerType<{
                    attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attestations: ListCompositeType<ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    committeeBits: BitVectorType;
                    }>>;
                    deposits: ListCompositeType<ContainerType<{
                    proof: VectorCompositeType<ByteVectorType>;
                    data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    voluntaryExits: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    syncAggregate: ContainerType<{
                        syncCommitteeBits: BitVectorType;
                        syncCommitteeSignature: ByteVectorType;
                    }>;
                    executionPayload: ContainerType<{
                        parentHash: ByteVectorType;
                        feeRecipient: ExecutionAddressType;
                        stateRoot: ByteVectorType;
                        receiptsRoot: ByteVectorType;
                        logsBloom: ByteVectorType;
                        prevRandao: ByteVectorType;
                        blockNumber: UintNumberType;
                        gasLimit: UintNumberType;
                        gasUsed: UintNumberType;
                        timestamp: UintNumberType;
                        extraData: ByteListType;
                        baseFeePerGas: UintBigintType;
                        blockHash: ByteVectorType;
                        transactions: ListCompositeType<ByteListType>;
                        withdrawals: ListCompositeType<ContainerType<{
                        index: UintNumberType;
                        validatorIndex: UintNumberType;
                        address: ExecutionAddressType;
                        amount: UintBigintType;
                        }>>;
                        blobGasUsed: UintBigintType;
                        excessBlobGas: UintBigintType;
                    }>;
                    blsToExecutionChanges: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    validatorIndex: UintNumberType;
                    fromBlsPubkey: ByteVectorType;
                    toExecutionAddress: ExecutionAddressType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    blobKzgCommitments: ListCompositeType<ByteVectorType>;
                    executionRequests: ContainerType<{
                        deposits: ListCompositeType<ContainerType<{
                        pubkey: ByteVectorType;
                        withdrawalCredentials: ByteVectorType;
                        amount: UintNumberType;
                        signature: ByteVectorType;
                        index: UintBigintType;
                        }>>;
                        withdrawals: ListCompositeType<ContainerType<{
                        sourceAddress: ExecutionAddressType;
                        validatorPubkey: ByteVectorType;
                        amount: UintBigintType;
                        }>>;
                        consolidations: ListCompositeType<ContainerType<{
                        sourceAddress: ExecutionAddressType;
                        sourcePubkey: ByteVectorType;
                        targetPubkey: ByteVectorType;
                        }>>;
                    }>;
                }>;
            }>;
            kzgProofs: ListCompositeType<ByteVectorType>;
            blobs: ListCompositeType<ByteVectorType>;
        }>;
        SignedBlockContents: ContainerType<{
            signedBlock: ContainerType<{
                message: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    body: ContainerType<{
                        randaoReveal: ByteVectorType;
                        eth1Data: ContainerType<{
                            depositRoot: ByteVectorType;
                            depositCount: UintNumberType;
                            blockHash: ByteVectorType;
                        }>;
                        graffiti: ByteVectorType;
                        proposerSlashings: ListCompositeType<ContainerType<{
                        signedHeader1: ContainerType<{
                        message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                        }>;
                        signature: ByteVectorType;
                        }>;
                        signedHeader2: ContainerType<{
                        message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                        }>;
                        signature: ByteVectorType;
                        }>;
                        }>>;
                        attesterSlashings: ListCompositeType<ContainerType<{
                        attestation1: ContainerType<{
                        attestingIndices: ListBasicType<UintNumberType>;
                        data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                        }>;
                        }>;
                        signature: ByteVectorType;
                        }>;
                        attestation2: ContainerType<{
                        attestingIndices: ListBasicType<UintNumberType>;
                        data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                        }>;
                        }>;
                        signature: ByteVectorType;
                        }>;
                        }>>;
                        attestations: ListCompositeType<ContainerType<{
                        aggregationBits: BitListType;
                        data: ContainerType<{
                        slot: UintNumberType;
                        index: UintNumberType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                        }>;
                        }>;
                        signature: ByteVectorType;
                        committeeBits: BitVectorType;
                        }>>;
                        deposits: ListCompositeType<ContainerType<{
                        proof: VectorCompositeType<ByteVectorType>;
                        data: ContainerType<{
                        pubkey: ByteVectorType;
                        withdrawalCredentials: ByteVectorType;
                        amount: UintNumberType;
                        signature: ByteVectorType;
                        }>;
                        }>>;
                        voluntaryExits: ListCompositeType<ContainerType<{
                        message: ContainerType<{
                        epoch: UintNumberType;
                        validatorIndex: UintNumberType;
                        }>;
                        signature: ByteVectorType;
                        }>>;
                        syncAggregate: ContainerType<{
                            syncCommitteeBits: BitVectorType;
                            syncCommitteeSignature: ByteVectorType;
                        }>;
                        executionPayload: ContainerType<{
                            parentHash: ByteVectorType;
                            feeRecipient: ExecutionAddressType;
                            stateRoot: ByteVectorType;
                            receiptsRoot: ByteVectorType;
                            logsBloom: ByteVectorType;
                            prevRandao: ByteVectorType;
                            blockNumber: UintNumberType;
                            gasLimit: UintNumberType;
                            gasUsed: UintNumberType;
                            timestamp: UintNumberType;
                            extraData: ByteListType;
                            baseFeePerGas: UintBigintType;
                            blockHash: ByteVectorType;
                            transactions: ListCompositeType<ByteListType>;
                            withdrawals: ListCompositeType<ContainerType<{
                            index: UintNumberType;
                            validatorIndex: UintNumberType;
                            address: ExecutionAddressType;
                            amount: UintBigintType;
                            }>>;
                            blobGasUsed: UintBigintType;
                            excessBlobGas: UintBigintType;
                        }>;
                        blsToExecutionChanges: ListCompositeType<ContainerType<{
                        message: ContainerType<{
                        validatorIndex: UintNumberType;
                        fromBlsPubkey: ByteVectorType;
                        toExecutionAddress: ExecutionAddressType;
                        }>;
                        signature: ByteVectorType;
                        }>>;
                        blobKzgCommitments: ListCompositeType<ByteVectorType>;
                        executionRequests: ContainerType<{
                            deposits: ListCompositeType<ContainerType<{
                            pubkey: ByteVectorType;
                            withdrawalCredentials: ByteVectorType;
                            amount: UintNumberType;
                            signature: ByteVectorType;
                            index: UintBigintType;
                            }>>;
                            withdrawals: ListCompositeType<ContainerType<{
                            sourceAddress: ExecutionAddressType;
                            validatorPubkey: ByteVectorType;
                            amount: UintBigintType;
                            }>>;
                            consolidations: ListCompositeType<ContainerType<{
                            sourceAddress: ExecutionAddressType;
                            sourcePubkey: ByteVectorType;
                            targetPubkey: ByteVectorType;
                            }>>;
                        }>;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            kzgProofs: ListCompositeType<ByteVectorType>;
            blobs: ListCompositeType<ByteVectorType>;
        }>;
    };
    gloas: {
        AttestationSubnets: BitVectorType;
        BeaconBlockHeader: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        BeaconBlockHeaderBigint: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
        }>;
        SignedBeaconBlockHeader: ContainerType<{
            message: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        SignedBeaconBlockHeaderBigint: ContainerType<{
            message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        Checkpoint: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
        }>;
        CheckpointBigint: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
        }>;
        CommitteeIndices: ListBasicType<UintNumberType>;
        DepositMessage: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
        }>;
        DepositData: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
        }>;
        DepositDataRootList: ListCompositeType<ByteVectorType>;
        DepositEvent: ContainerType<{
            depositData: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
            }>;
            blockNumber: UintNumberType;
            index: UintNumberType;
        }>;
        Eth1Data: ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
        }>;
        Eth1DataVotes: ListCompositeType<ContainerType<{
        depositRoot: ByteVectorType;
        depositCount: UintNumberType;
        blockHash: ByteVectorType;
        }>>;
        Eth1DataOrdered: ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
            blockNumber: UintNumberType;
        }>;
        Eth1Block: ContainerType<{
            timestamp: UintNumberType;
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
        }>;
        Fork: ContainerType<{
            previousVersion: ByteVectorType;
            currentVersion: ByteVectorType;
            epoch: UintNumberType;
        }>;
        ForkData: ContainerType<{
            currentVersion: ByteVectorType;
            genesisValidatorsRoot: ByteVectorType;
        }>;
        ENRForkID: ContainerType<{
            forkDigest: ByteVectorType;
            nextForkVersion: ByteVectorType;
            nextForkEpoch: UintNumberType;
        }>;
        HistoricalBlockRoots: VectorCompositeType<ByteVectorType>;
        HistoricalStateRoots: VectorCompositeType<ByteVectorType>;
        HistoricalBatch: ContainerType<{
            blockRoots: VectorCompositeType<ByteVectorType>;
            stateRoots: VectorCompositeType<ByteVectorType>;
        }>;
        HistoricalBatchRoots: ContainerType<{
            blockRoots: ByteVectorType;
            stateRoots: ByteVectorType;
        }>;
        Validator: ValidatorNodeStructType;
        Validators: ListCompositeType<ValidatorNodeStructType>;
        Balances: ListUintNum64Type;
        RandaoMixes: VectorCompositeType<ByteVectorType>;
        Slashings: VectorBasicType<UintNumberType>;
        JustificationBits: BitVectorType;
        AttestationData: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
        }>;
        AttestationDataBigint: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
            }>;
            target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
            }>;
        }>;
        PendingAttestation: ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            inclusionDelay: UintNumberType;
            proposerIndex: UintNumberType;
        }>;
        SigningData: ContainerType<{
            objectRoot: ByteVectorType;
            domain: ByteVectorType;
        }>;
        Deposit: ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
            }>;
        }>;
        ProposerSlashing: ContainerType<{
            signedHeader1: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
                message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
        }>;
        VoluntaryExit: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
        }>;
        SignedVoluntaryExit: ContainerType<{
            message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
        }>;
        EpochAttestations: ListCompositeType<ContainerType<{
        aggregationBits: BitListType;
        data: ContainerType<{
        slot: UintNumberType;
        index: UintNumberType;
        beaconBlockRoot: ByteVectorType;
        source: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
        }>;
        target: ContainerType<{
        epoch: UintNumberType;
        root: ByteVectorType;
        }>;
        }>;
        inclusionDelay: UintNumberType;
        proposerIndex: UintNumberType;
        }>>;
        CommitteeAssignment: ContainerType<{
            validators: ListBasicType<UintNumberType>;
            committeeIndex: UintNumberType;
            slot: UintNumberType;
        }>;
        Goodbye: UintBigintType;
        Ping: UintBigintType;
        BeaconBlocksByRangeRequest: ContainerType<{
            startSlot: UintNumberType;
            count: UintNumberType;
            step: UintNumberType;
        }>;
        Genesis: ContainerType<{
            genesisValidatorsRoot: ByteVectorType;
            genesisTime: UintNumberType;
            genesisForkVersion: ByteVectorType;
        }>;
        SyncSubnets: BitVectorType;
        SyncCommittee: ContainerType<{
            pubkeys: VectorCompositeType<ByteVectorType>;
            aggregatePubkey: ByteVectorType;
        }>;
        SyncCommitteeMessage: ContainerType<{
            slot: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            validatorIndex: UintNumberType;
            signature: ByteVectorType;
        }>;
        SyncCommitteeContribution: ContainerType<{
            slot: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            subcommitteeIndex: UintNumberType;
            aggregationBits: BitVectorType;
            signature: ByteVectorType;
        }>;
        ContributionAndProof: ContainerType<{
            aggregatorIndex: UintNumberType;
            contribution: ContainerType<{
                slot: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                subcommitteeIndex: UintNumberType;
                aggregationBits: BitVectorType;
                signature: ByteVectorType;
            }>;
            selectionProof: ByteVectorType;
        }>;
        SignedContributionAndProof: ContainerType<{
            message: ContainerType<{
                aggregatorIndex: UintNumberType;
                contribution: ContainerType<{
                    slot: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    subcommitteeIndex: UintNumberType;
                    aggregationBits: BitVectorType;
                    signature: ByteVectorType;
                }>;
                selectionProof: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        SyncAggregatorSelectionData: ContainerType<{
            slot: UintNumberType;
            subcommitteeIndex: UintNumberType;
        }>;
        SyncCommitteeBits: BitVectorType;
        SyncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
        }>;
        EpochParticipation: ListBasicType<UintNumberType>;
        InactivityScores: ListBasicType<UintNumberType>;
        LightClientUpdatesByRange: ContainerType<{
            startPeriod: UintNumberType;
            count: UintNumberType;
        }>;
        Transaction: ByteListType;
        Transactions: ListCompositeType<ByteListType>;
        CommonExecutionPayloadType: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
        }>;
        PowBlock: ContainerType<{
            blockHash: ByteVectorType;
            parentHash: ByteVectorType;
            totalDifficulty: UintBigintType;
        }>;
        ValidatorRegistrationV1: ContainerType<{
            feeRecipient: ExecutionAddressType;
            gasLimit: UintNumberType;
            timestamp: UintNumberType;
            pubkey: ByteVectorType;
        }>;
        SignedValidatorRegistrationV1: ContainerType<{
            message: ContainerType<{
                feeRecipient: ExecutionAddressType;
                gasLimit: UintNumberType;
                timestamp: UintNumberType;
                pubkey: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        SSEPayloadAttributesCommon: ContainerType<{
            proposerIndex: UintNumberType;
            proposalSlot: UintNumberType;
            parentBlockNumber: UintNumberType;
            parentBlockRoot: ByteVectorType;
            parentBlockHash: ByteVectorType;
        }>;
        ExecutionBranch: VectorCompositeType<ByteVectorType>;
        Withdrawal: ContainerType<{
            index: UintNumberType;
            validatorIndex: UintNumberType;
            address: ExecutionAddressType;
            amount: UintBigintType;
        }>;
        BLSToExecutionChange: ContainerType<{
            validatorIndex: UintNumberType;
            fromBlsPubkey: ByteVectorType;
            toExecutionAddress: ExecutionAddressType;
        }>;
        SignedBLSToExecutionChange: ContainerType<{
            message: ContainerType<{
                validatorIndex: UintNumberType;
                fromBlsPubkey: ByteVectorType;
                toExecutionAddress: ExecutionAddressType;
            }>;
            signature: ByteVectorType;
        }>;
        Withdrawals: ListCompositeType<ContainerType<{
        index: UintNumberType;
        validatorIndex: UintNumberType;
        address: ExecutionAddressType;
        amount: UintBigintType;
        }>>;
        BLSToExecutionChanges: ListCompositeType<ContainerType<{
        message: ContainerType<{
        validatorIndex: UintNumberType;
        fromBlsPubkey: ByteVectorType;
        toExecutionAddress: ExecutionAddressType;
        }>;
        signature: ByteVectorType;
        }>>;
        HistoricalSummary: ContainerType<{
            blockSummaryRoot: ByteVectorType;
            stateSummaryRoot: ByteVectorType;
        }>;
        HistoricalSummaries: ListCompositeType<ContainerType<{
        blockSummaryRoot: ByteVectorType;
        stateSummaryRoot: ByteVectorType;
        }>>;
        G1Point: ByteVectorType;
        G2Point: ByteVectorType;
        BLSFieldElement: ByteVectorType;
        KZGCommitment: ByteVectorType;
        Blobs: ListCompositeType<ByteVectorType>;
        BlindedBlob: ByteVectorType;
        BlindedBlobs: ListCompositeType<ByteVectorType>;
        VersionedHash: ByteVectorType;
        BlobKzgCommitments: ListCompositeType<ByteVectorType>;
        BlobSidecarsByRangeRequest: ContainerType<{
            startSlot: UintNumberType;
            count: UintNumberType;
        }>;
        BlobIdentifier: ContainerType<{
            blockRoot: ByteVectorType;
            index: UintNumberType;
        }>;
        KzgCommitmentInclusionProof: VectorCompositeType<ByteVectorType>;
        BlobSidecar: ContainerType<{
            index: UintNumberType;
            blob: ByteVectorType;
            kzgCommitment: ByteVectorType;
            kzgProof: ByteVectorType;
            signedBlockHeader: ContainerType<{
                message: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
            kzgCommitmentInclusionProof: VectorCompositeType<ByteVectorType>;
        }>;
        BlobSidecars: ListCompositeType<ContainerType<{
        index: UintNumberType;
        blob: ByteVectorType;
        kzgCommitment: ByteVectorType;
        kzgProof: ByteVectorType;
        signedBlockHeader: ContainerType<{
        message: ContainerType<{
        slot: UintNumberType;
        proposerIndex: UintNumberType;
        parentRoot: ByteVectorType;
        stateRoot: ByteVectorType;
        bodyRoot: ByteVectorType;
        }>;
        signature: ByteVectorType;
        }>;
        kzgCommitmentInclusionProof: VectorCompositeType<ByteVectorType>;
        }>>;
        LightClientHeader: ContainerType<{
            beacon: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            execution: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            executionBranch: VectorCompositeType<ByteVectorType>;
        }>;
        CurrentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
        FinalityBranch: VectorCompositeType<ByteVectorType>;
        NextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
        AggregationBits: BitListType;
        CommitteeBits: BitVectorType;
        AttestingIndices: ListBasicType<UintNumberType>;
        Attestation: ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
            committeeBits: BitVectorType;
        }>;
        SingleAttestation: ContainerType<{
            committeeIndex: UintNumberType;
            attesterIndex: UintNumberType;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        IndexedAttestation: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        IndexedAttestationBigint: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        AttesterSlashing: ContainerType<{
            attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
        }>;
        AggregateAndProof: ContainerType<{
            aggregatorIndex: UintNumberType;
            aggregate: ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                    }>;
                }>;
                signature: ByteVectorType;
                committeeBits: BitVectorType;
            }>;
            selectionProof: ByteVectorType;
        }>;
        SignedAggregateAndProof: ContainerType<{
            message: ContainerType<{
                aggregatorIndex: UintNumberType;
                aggregate: ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                        slot: UintNumberType;
                        index: UintNumberType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                            epoch: UintNumberType;
                            root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                            epoch: UintNumberType;
                            root: ByteVectorType;
                        }>;
                    }>;
                    signature: ByteVectorType;
                    committeeBits: BitVectorType;
                }>;
                selectionProof: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        DepositRequest: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            index: UintBigintType;
        }>;
        DepositRequests: ListCompositeType<ContainerType<{
        pubkey: ByteVectorType;
        withdrawalCredentials: ByteVectorType;
        amount: UintNumberType;
        signature: ByteVectorType;
        index: UintBigintType;
        }>>;
        WithdrawalRequest: ContainerType<{
            sourceAddress: ExecutionAddressType;
            validatorPubkey: ByteVectorType;
            amount: UintBigintType;
        }>;
        WithdrawalRequests: ListCompositeType<ContainerType<{
        sourceAddress: ExecutionAddressType;
        validatorPubkey: ByteVectorType;
        amount: UintBigintType;
        }>>;
        ConsolidationRequest: ContainerType<{
            sourceAddress: ExecutionAddressType;
            sourcePubkey: ByteVectorType;
            targetPubkey: ByteVectorType;
        }>;
        ConsolidationRequests: ListCompositeType<ContainerType<{
        sourceAddress: ExecutionAddressType;
        sourcePubkey: ByteVectorType;
        targetPubkey: ByteVectorType;
        }>>;
        ExecutionRequests: ContainerType<{
            deposits: ListCompositeType<ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            index: UintBigintType;
            }>>;
            withdrawals: ListCompositeType<ContainerType<{
            sourceAddress: ExecutionAddressType;
            validatorPubkey: ByteVectorType;
            amount: UintBigintType;
            }>>;
            consolidations: ListCompositeType<ContainerType<{
            sourceAddress: ExecutionAddressType;
            sourcePubkey: ByteVectorType;
            targetPubkey: ByteVectorType;
            }>>;
        }>;
        ExecutionPayloadHeader: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
        }>;
        BlindedBeaconBlockBody: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
            signedHeader1: ContainerType<{
            message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
            message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
            }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
            attestation1: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            committeeBits: BitVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
            message: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
            }>>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            executionPayloadHeader: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            blsToExecutionChanges: ListCompositeType<ContainerType<{
            message: ContainerType<{
            validatorIndex: UintNumberType;
            fromBlsPubkey: ByteVectorType;
            toExecutionAddress: ExecutionAddressType;
            }>;
            signature: ByteVectorType;
            }>>;
            blobKzgCommitments: ListCompositeType<ByteVectorType>;
            executionRequests: ContainerType<{
                deposits: ListCompositeType<ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                index: UintBigintType;
                }>>;
                withdrawals: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                validatorPubkey: ByteVectorType;
                amount: UintBigintType;
                }>>;
                consolidations: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                sourcePubkey: ByteVectorType;
                targetPubkey: ByteVectorType;
                }>>;
            }>;
        }>;
        BlindedBeaconBlock: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            body: ContainerType<{
                randaoReveal: ByteVectorType;
                eth1Data: ContainerType<{
                    depositRoot: ByteVectorType;
                    depositCount: UintNumberType;
                    blockHash: ByteVectorType;
                }>;
                graffiti: ByteVectorType;
                proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
                }>;
                }>>;
                attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>;
                }>>;
                attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                committeeBits: BitVectorType;
                }>>;
                deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                }>;
                }>>;
                voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
                }>>;
                syncAggregate: ContainerType<{
                    syncCommitteeBits: BitVectorType;
                    syncCommitteeSignature: ByteVectorType;
                }>;
                executionPayloadHeader: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                blsToExecutionChanges: ListCompositeType<ContainerType<{
                message: ContainerType<{
                validatorIndex: UintNumberType;
                fromBlsPubkey: ByteVectorType;
                toExecutionAddress: ExecutionAddressType;
                }>;
                signature: ByteVectorType;
                }>>;
                blobKzgCommitments: ListCompositeType<ByteVectorType>;
                executionRequests: ContainerType<{
                    deposits: ListCompositeType<ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    index: UintBigintType;
                    }>>;
                    withdrawals: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    validatorPubkey: ByteVectorType;
                    amount: UintBigintType;
                    }>>;
                    consolidations: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    sourcePubkey: ByteVectorType;
                    targetPubkey: ByteVectorType;
                    }>>;
                }>;
            }>;
        }>;
        SignedBlindedBeaconBlock: ContainerType<{
            message: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                body: ContainerType<{
                    randaoReveal: ByteVectorType;
                    eth1Data: ContainerType<{
                        depositRoot: ByteVectorType;
                        depositCount: UintNumberType;
                        blockHash: ByteVectorType;
                    }>;
                    graffiti: ByteVectorType;
                    proposerSlashings: ListCompositeType<ContainerType<{
                    signedHeader1: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    signedHeader2: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attesterSlashings: ListCompositeType<ContainerType<{
                    attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attestations: ListCompositeType<ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    committeeBits: BitVectorType;
                    }>>;
                    deposits: ListCompositeType<ContainerType<{
                    proof: VectorCompositeType<ByteVectorType>;
                    data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    voluntaryExits: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    syncAggregate: ContainerType<{
                        syncCommitteeBits: BitVectorType;
                        syncCommitteeSignature: ByteVectorType;
                    }>;
                    executionPayloadHeader: ContainerType<{
                        parentHash: ByteVectorType;
                        feeRecipient: ExecutionAddressType;
                        stateRoot: ByteVectorType;
                        receiptsRoot: ByteVectorType;
                        logsBloom: ByteVectorType;
                        prevRandao: ByteVectorType;
                        blockNumber: UintNumberType;
                        gasLimit: UintNumberType;
                        gasUsed: UintNumberType;
                        timestamp: UintNumberType;
                        extraData: ByteListType;
                        baseFeePerGas: UintBigintType;
                        blockHash: ByteVectorType;
                        transactionsRoot: ByteVectorType;
                        withdrawalsRoot: ByteVectorType;
                        blobGasUsed: UintBigintType;
                        excessBlobGas: UintBigintType;
                    }>;
                    blsToExecutionChanges: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    validatorIndex: UintNumberType;
                    fromBlsPubkey: ByteVectorType;
                    toExecutionAddress: ExecutionAddressType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    blobKzgCommitments: ListCompositeType<ByteVectorType>;
                    executionRequests: ContainerType<{
                        deposits: ListCompositeType<ContainerType<{
                        pubkey: ByteVectorType;
                        withdrawalCredentials: ByteVectorType;
                        amount: UintNumberType;
                        signature: ByteVectorType;
                        index: UintBigintType;
                        }>>;
                        withdrawals: ListCompositeType<ContainerType<{
                        sourceAddress: ExecutionAddressType;
                        validatorPubkey: ByteVectorType;
                        amount: UintBigintType;
                        }>>;
                        consolidations: ListCompositeType<ContainerType<{
                        sourceAddress: ExecutionAddressType;
                        sourcePubkey: ByteVectorType;
                        targetPubkey: ByteVectorType;
                        }>>;
                    }>;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        BuilderBid: ContainerType<{
            header: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactionsRoot: ByteVectorType;
                withdrawalsRoot: ByteVectorType;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            blobKzgCommitments: ListCompositeType<ByteVectorType>;
            executionRequests: ContainerType<{
                deposits: ListCompositeType<ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                index: UintBigintType;
                }>>;
                withdrawals: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                validatorPubkey: ByteVectorType;
                amount: UintBigintType;
                }>>;
                consolidations: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                sourcePubkey: ByteVectorType;
                targetPubkey: ByteVectorType;
                }>>;
            }>;
            value: UintBigintType;
            pubkey: ByteVectorType;
        }>;
        SignedBuilderBid: ContainerType<{
            message: ContainerType<{
                header: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                blobKzgCommitments: ListCompositeType<ByteVectorType>;
                executionRequests: ContainerType<{
                    deposits: ListCompositeType<ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    index: UintBigintType;
                    }>>;
                    withdrawals: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    validatorPubkey: ByteVectorType;
                    amount: UintBigintType;
                    }>>;
                    consolidations: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    sourcePubkey: ByteVectorType;
                    targetPubkey: ByteVectorType;
                    }>>;
                }>;
                value: UintBigintType;
                pubkey: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        PendingDeposit: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            slot: UintNumberType;
        }>;
        PendingDeposits: ListCompositeType<ContainerType<{
        pubkey: ByteVectorType;
        withdrawalCredentials: ByteVectorType;
        amount: UintNumberType;
        signature: ByteVectorType;
        slot: UintNumberType;
        }>>;
        PendingPartialWithdrawal: ContainerType<{
            validatorIndex: UintNumberType;
            amount: UintBigintType;
            withdrawableEpoch: UintNumberType;
        }>;
        PendingPartialWithdrawals: ListCompositeType<ContainerType<{
        validatorIndex: UintNumberType;
        amount: UintBigintType;
        withdrawableEpoch: UintNumberType;
        }>>;
        PendingConsolidation: ContainerType<{
            sourceIndex: UintNumberType;
            targetIndex: UintNumberType;
        }>;
        PendingConsolidations: ListCompositeType<ContainerType<{
        sourceIndex: UintNumberType;
        targetIndex: UintNumberType;
        }>>;
        LightClientBootstrap: ContainerType<{
            header: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            currentSyncCommittee: ContainerType<{
                pubkeys: VectorCompositeType<ByteVectorType>;
                aggregatePubkey: ByteVectorType;
            }>;
            currentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
        }>;
        LightClientUpdate: ContainerType<{
            attestedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            nextSyncCommittee: ContainerType<{
                pubkeys: VectorCompositeType<ByteVectorType>;
                aggregatePubkey: ByteVectorType;
            }>;
            nextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
            finalizedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            finalityBranch: VectorCompositeType<ByteVectorType>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            signatureSlot: UintNumberType;
        }>;
        LightClientFinalityUpdate: ContainerType<{
            attestedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            finalizedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            finalityBranch: VectorCompositeType<ByteVectorType>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            signatureSlot: UintNumberType;
        }>;
        LightClientOptimisticUpdate: ContainerType<{
            attestedHeader: ContainerType<{
                beacon: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                }>;
                execution: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactionsRoot: ByteVectorType;
                    withdrawalsRoot: ByteVectorType;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                }>;
                executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            signatureSlot: UintNumberType;
        }>;
        LightClientStore: ContainerType<{
            snapshot: ContainerType<{
                header: ContainerType<{
                    beacon: ContainerType<{
                        slot: UintNumberType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                    }>;
                    execution: ContainerType<{
                        parentHash: ByteVectorType;
                        feeRecipient: ExecutionAddressType;
                        stateRoot: ByteVectorType;
                        receiptsRoot: ByteVectorType;
                        logsBloom: ByteVectorType;
                        prevRandao: ByteVectorType;
                        blockNumber: UintNumberType;
                        gasLimit: UintNumberType;
                        gasUsed: UintNumberType;
                        timestamp: UintNumberType;
                        extraData: ByteListType;
                        baseFeePerGas: UintBigintType;
                        blockHash: ByteVectorType;
                        transactionsRoot: ByteVectorType;
                        withdrawalsRoot: ByteVectorType;
                        blobGasUsed: UintBigintType;
                        excessBlobGas: UintBigintType;
                    }>;
                    executionBranch: VectorCompositeType<ByteVectorType>;
                }>;
                currentSyncCommittee: ContainerType<{
                    pubkeys: VectorCompositeType<ByteVectorType>;
                    aggregatePubkey: ByteVectorType;
                }>;
                currentSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
            }>;
            validUpdates: ListCompositeType<ContainerType<{
            attestedHeader: ContainerType<{
            beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            execution: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
            }>;
            executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            nextSyncCommittee: ContainerType<{
            pubkeys: VectorCompositeType<ByteVectorType>;
            aggregatePubkey: ByteVectorType;
            }>;
            nextSyncCommitteeBranch: VectorCompositeType<ByteVectorType>;
            finalizedHeader: ContainerType<{
            beacon: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            execution: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactionsRoot: ByteVectorType;
            withdrawalsRoot: ByteVectorType;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
            }>;
            executionBranch: VectorCompositeType<ByteVectorType>;
            }>;
            finalityBranch: VectorCompositeType<ByteVectorType>;
            syncAggregate: ContainerType<{
            syncCommitteeBits: BitVectorType;
            syncCommitteeSignature: ByteVectorType;
            }>;
            signatureSlot: UintNumberType;
            }>>;
        }>;
        KZGProof: ByteVectorType;
        Blob: ByteVectorType;
        Metadata: ContainerType<{
            seqNumber: UintBigintType;
            attnets: BitVectorType;
            syncnets: BitVectorType;
            custodyGroupCount: UintNumberType;
        }>;
        Status: ContainerType<{
            forkDigest: ByteVectorType;
            finalizedRoot: ByteVectorType;
            finalizedEpoch: UintNumberType;
            headRoot: ByteVectorType;
            headSlot: UintNumberType;
            earliestAvailableSlot: UintNumberType;
        }>;
        Cell: ByteVectorType;
        DataColumn: ListCompositeType<ByteVectorType>;
        DataColumns: ListCompositeType<ListCompositeType<ByteVectorType>>;
        ExtendedMatrix: ListCompositeType<ByteVectorType>;
        KzgCommitmentsInclusionProof: VectorCompositeType<ByteVectorType>;
        KZGProofs: ListCompositeType<ByteVectorType>;
        ProposerLookahead: VectorBasicType<UintNumberType>;
        MatrixEntry: ContainerType<{
            cell: ByteVectorType;
            kzgProof: ByteVectorType;
            columnIndex: UintNumberType;
            rowIndex: UintNumberType;
        }>;
        DataColumnsByRootIdentifier: ContainerType<{
            blockRoot: ByteVectorType;
            columns: ListBasicType<UintNumberType>;
        }>;
        DataColumnSidecarsByRangeRequest: ContainerType<{
            startSlot: UintNumberType;
            count: UintNumberType;
            columns: ListBasicType<UintNumberType>;
        }>;
        BeaconBlocksByHeadRequest: ContainerType<{
            beaconRoot: ByteVectorType;
            count: UintNumberType;
        }>;
        BlobsBundle: ContainerType<{
            commitments: ListCompositeType<ByteVectorType>;
            proofs: ListCompositeType<ByteVectorType>;
            blobs: ListCompositeType<ByteVectorType>;
        }>;
        ExecutionPayloadAndBlobsBundle: ContainerType<{
            executionPayload: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactions: ListCompositeType<ByteListType>;
                withdrawals: ListCompositeType<ContainerType<{
                index: UintNumberType;
                validatorIndex: UintNumberType;
                address: ExecutionAddressType;
                amount: UintBigintType;
                }>>;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
            }>;
            blobsBundle: ContainerType<{
                commitments: ListCompositeType<ByteVectorType>;
                proofs: ListCompositeType<ByteVectorType>;
                blobs: ListCompositeType<ByteVectorType>;
            }>;
        }>;
        BlockContents: ContainerType<{
            block: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                body: ContainerType<{
                    randaoReveal: ByteVectorType;
                    eth1Data: ContainerType<{
                        depositRoot: ByteVectorType;
                        depositCount: UintNumberType;
                        blockHash: ByteVectorType;
                    }>;
                    graffiti: ByteVectorType;
                    proposerSlashings: ListCompositeType<ContainerType<{
                    signedHeader1: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    signedHeader2: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attesterSlashings: ListCompositeType<ContainerType<{
                    attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attestations: ListCompositeType<ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    committeeBits: BitVectorType;
                    }>>;
                    deposits: ListCompositeType<ContainerType<{
                    proof: VectorCompositeType<ByteVectorType>;
                    data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    voluntaryExits: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    syncAggregate: ContainerType<{
                        syncCommitteeBits: BitVectorType;
                        syncCommitteeSignature: ByteVectorType;
                    }>;
                    executionPayload: ContainerType<{
                        parentHash: ByteVectorType;
                        feeRecipient: ExecutionAddressType;
                        stateRoot: ByteVectorType;
                        receiptsRoot: ByteVectorType;
                        logsBloom: ByteVectorType;
                        prevRandao: ByteVectorType;
                        blockNumber: UintNumberType;
                        gasLimit: UintNumberType;
                        gasUsed: UintNumberType;
                        timestamp: UintNumberType;
                        extraData: ByteListType;
                        baseFeePerGas: UintBigintType;
                        blockHash: ByteVectorType;
                        transactions: ListCompositeType<ByteListType>;
                        withdrawals: ListCompositeType<ContainerType<{
                        index: UintNumberType;
                        validatorIndex: UintNumberType;
                        address: ExecutionAddressType;
                        amount: UintBigintType;
                        }>>;
                        blobGasUsed: UintBigintType;
                        excessBlobGas: UintBigintType;
                    }>;
                    blsToExecutionChanges: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    validatorIndex: UintNumberType;
                    fromBlsPubkey: ByteVectorType;
                    toExecutionAddress: ExecutionAddressType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    blobKzgCommitments: ListCompositeType<ByteVectorType>;
                    executionRequests: ContainerType<{
                        deposits: ListCompositeType<ContainerType<{
                        pubkey: ByteVectorType;
                        withdrawalCredentials: ByteVectorType;
                        amount: UintNumberType;
                        signature: ByteVectorType;
                        index: UintBigintType;
                        }>>;
                        withdrawals: ListCompositeType<ContainerType<{
                        sourceAddress: ExecutionAddressType;
                        validatorPubkey: ByteVectorType;
                        amount: UintBigintType;
                        }>>;
                        consolidations: ListCompositeType<ContainerType<{
                        sourceAddress: ExecutionAddressType;
                        sourcePubkey: ByteVectorType;
                        targetPubkey: ByteVectorType;
                        }>>;
                    }>;
                }>;
            }>;
            kzgProofs: ListCompositeType<ByteVectorType>;
            blobs: ListCompositeType<ByteVectorType>;
        }>;
        SignedBlockContents: ContainerType<{
            signedBlock: ContainerType<{
                message: ContainerType<{
                    slot: UintNumberType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    body: ContainerType<{
                        randaoReveal: ByteVectorType;
                        eth1Data: ContainerType<{
                            depositRoot: ByteVectorType;
                            depositCount: UintNumberType;
                            blockHash: ByteVectorType;
                        }>;
                        graffiti: ByteVectorType;
                        proposerSlashings: ListCompositeType<ContainerType<{
                        signedHeader1: ContainerType<{
                        message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                        }>;
                        signature: ByteVectorType;
                        }>;
                        signedHeader2: ContainerType<{
                        message: ContainerType<{
                        slot: UintBigintType;
                        proposerIndex: UintNumberType;
                        parentRoot: ByteVectorType;
                        stateRoot: ByteVectorType;
                        bodyRoot: ByteVectorType;
                        }>;
                        signature: ByteVectorType;
                        }>;
                        }>>;
                        attesterSlashings: ListCompositeType<ContainerType<{
                        attestation1: ContainerType<{
                        attestingIndices: ListBasicType<UintNumberType>;
                        data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                        }>;
                        }>;
                        signature: ByteVectorType;
                        }>;
                        attestation2: ContainerType<{
                        attestingIndices: ListBasicType<UintNumberType>;
                        data: ContainerType<{
                        slot: UintBigintType;
                        index: UintBigintType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                        epoch: UintBigintType;
                        root: ByteVectorType;
                        }>;
                        }>;
                        signature: ByteVectorType;
                        }>;
                        }>>;
                        attestations: ListCompositeType<ContainerType<{
                        aggregationBits: BitListType;
                        data: ContainerType<{
                        slot: UintNumberType;
                        index: UintNumberType;
                        beaconBlockRoot: ByteVectorType;
                        source: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                        }>;
                        target: ContainerType<{
                        epoch: UintNumberType;
                        root: ByteVectorType;
                        }>;
                        }>;
                        signature: ByteVectorType;
                        committeeBits: BitVectorType;
                        }>>;
                        deposits: ListCompositeType<ContainerType<{
                        proof: VectorCompositeType<ByteVectorType>;
                        data: ContainerType<{
                        pubkey: ByteVectorType;
                        withdrawalCredentials: ByteVectorType;
                        amount: UintNumberType;
                        signature: ByteVectorType;
                        }>;
                        }>>;
                        voluntaryExits: ListCompositeType<ContainerType<{
                        message: ContainerType<{
                        epoch: UintNumberType;
                        validatorIndex: UintNumberType;
                        }>;
                        signature: ByteVectorType;
                        }>>;
                        syncAggregate: ContainerType<{
                            syncCommitteeBits: BitVectorType;
                            syncCommitteeSignature: ByteVectorType;
                        }>;
                        executionPayload: ContainerType<{
                            parentHash: ByteVectorType;
                            feeRecipient: ExecutionAddressType;
                            stateRoot: ByteVectorType;
                            receiptsRoot: ByteVectorType;
                            logsBloom: ByteVectorType;
                            prevRandao: ByteVectorType;
                            blockNumber: UintNumberType;
                            gasLimit: UintNumberType;
                            gasUsed: UintNumberType;
                            timestamp: UintNumberType;
                            extraData: ByteListType;
                            baseFeePerGas: UintBigintType;
                            blockHash: ByteVectorType;
                            transactions: ListCompositeType<ByteListType>;
                            withdrawals: ListCompositeType<ContainerType<{
                            index: UintNumberType;
                            validatorIndex: UintNumberType;
                            address: ExecutionAddressType;
                            amount: UintBigintType;
                            }>>;
                            blobGasUsed: UintBigintType;
                            excessBlobGas: UintBigintType;
                        }>;
                        blsToExecutionChanges: ListCompositeType<ContainerType<{
                        message: ContainerType<{
                        validatorIndex: UintNumberType;
                        fromBlsPubkey: ByteVectorType;
                        toExecutionAddress: ExecutionAddressType;
                        }>;
                        signature: ByteVectorType;
                        }>>;
                        blobKzgCommitments: ListCompositeType<ByteVectorType>;
                        executionRequests: ContainerType<{
                            deposits: ListCompositeType<ContainerType<{
                            pubkey: ByteVectorType;
                            withdrawalCredentials: ByteVectorType;
                            amount: UintNumberType;
                            signature: ByteVectorType;
                            index: UintBigintType;
                            }>>;
                            withdrawals: ListCompositeType<ContainerType<{
                            sourceAddress: ExecutionAddressType;
                            validatorPubkey: ByteVectorType;
                            amount: UintBigintType;
                            }>>;
                            consolidations: ListCompositeType<ContainerType<{
                            sourceAddress: ExecutionAddressType;
                            sourcePubkey: ByteVectorType;
                            targetPubkey: ByteVectorType;
                            }>>;
                        }>;
                    }>;
                }>;
                signature: ByteVectorType;
            }>;
            kzgProofs: ListCompositeType<ByteVectorType>;
            blobs: ListCompositeType<ByteVectorType>;
        }>;
        Builder: ContainerType<{
            pubkey: ByteVectorType;
            version: UintNumberType;
            executionAddress: ExecutionAddressType;
            balance: UintNumberType;
            depositEpoch: UintNumberType;
            withdrawableEpoch: UintNumberType;
        }>;
        BuilderPendingWithdrawal: ContainerType<{
            feeRecipient: ExecutionAddressType;
            amount: UintNumberType;
            builderIndex: UintNumberType;
        }>;
        BuilderPendingPayment: ContainerType<{
            weight: UintNumberType;
            withdrawal: ContainerType<{
                feeRecipient: ExecutionAddressType;
                amount: UintNumberType;
                builderIndex: UintNumberType;
            }>;
        }>;
        PayloadTimelinessCommittee: VectorBasicType<UintNumberType>;
        PtcWindow: VectorCompositeType<VectorBasicType<UintNumberType>>;
        PayloadAttestationData: ContainerType<{
            beaconBlockRoot: ByteVectorType;
            slot: UintNumberType;
            payloadPresent: BooleanType;
            blobDataAvailable: BooleanType;
        }>;
        PayloadAttestation: ContainerType<{
            aggregationBits: BitVectorType;
            data: ContainerType<{
                beaconBlockRoot: ByteVectorType;
                slot: UintNumberType;
                payloadPresent: BooleanType;
                blobDataAvailable: BooleanType;
            }>;
            signature: ByteVectorType;
        }>;
        PayloadAttestationMessage: ContainerType<{
            validatorIndex: UintNumberType;
            data: ContainerType<{
                beaconBlockRoot: ByteVectorType;
                slot: UintNumberType;
                payloadPresent: BooleanType;
                blobDataAvailable: BooleanType;
            }>;
            signature: ByteVectorType;
        }>;
        IndexedPayloadAttestation: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
                beaconBlockRoot: ByteVectorType;
                slot: UintNumberType;
                payloadPresent: BooleanType;
                blobDataAvailable: BooleanType;
            }>;
            signature: ByteVectorType;
        }>;
        ProposerPreferences: ContainerType<{
            dependentRoot: ByteVectorType;
            proposalSlot: UintNumberType;
            validatorIndex: UintNumberType;
            feeRecipient: ExecutionAddressType;
            gasLimit: UintNumberType;
        }>;
        SignedProposerPreferences: ContainerType<{
            message: ContainerType<{
                dependentRoot: ByteVectorType;
                proposalSlot: UintNumberType;
                validatorIndex: UintNumberType;
                feeRecipient: ExecutionAddressType;
                gasLimit: UintNumberType;
            }>;
            signature: ByteVectorType;
        }>;
        ExecutionPayloadBid: ContainerType<{
            parentBlockHash: ByteVectorType;
            parentBlockRoot: ByteVectorType;
            blockHash: ByteVectorType;
            prevRandao: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            gasLimit: UintBigintType;
            builderIndex: UintNumberType;
            slot: UintNumberType;
            value: UintNumberType;
            executionPayment: UintNumberType;
            blobKzgCommitments: ListCompositeType<ByteVectorType>;
            executionRequestsRoot: ByteVectorType;
        }>;
        SignedExecutionPayloadBid: ContainerType<{
            message: ContainerType<{
                parentBlockHash: ByteVectorType;
                parentBlockRoot: ByteVectorType;
                blockHash: ByteVectorType;
                prevRandao: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                gasLimit: UintBigintType;
                builderIndex: UintNumberType;
                slot: UintNumberType;
                value: UintNumberType;
                executionPayment: UintNumberType;
                blobKzgCommitments: ListCompositeType<ByteVectorType>;
                executionRequestsRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        BlockAccessList: ByteListType;
        ExecutionPayload: ContainerType<{
            parentHash: ByteVectorType;
            feeRecipient: ExecutionAddressType;
            stateRoot: ByteVectorType;
            receiptsRoot: ByteVectorType;
            logsBloom: ByteVectorType;
            prevRandao: ByteVectorType;
            blockNumber: UintNumberType;
            gasLimit: UintNumberType;
            gasUsed: UintNumberType;
            timestamp: UintNumberType;
            extraData: ByteListType;
            baseFeePerGas: UintBigintType;
            blockHash: ByteVectorType;
            transactions: ListCompositeType<ByteListType>;
            withdrawals: ListCompositeType<ContainerType<{
            index: UintNumberType;
            validatorIndex: UintNumberType;
            address: ExecutionAddressType;
            amount: UintBigintType;
            }>>;
            blobGasUsed: UintBigintType;
            excessBlobGas: UintBigintType;
            blockAccessList: ByteListType;
            slotNumber: UintNumberType;
        }>;
        ExecutionPayloadEnvelope: ContainerType<{
            payload: ContainerType<{
                parentHash: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                stateRoot: ByteVectorType;
                receiptsRoot: ByteVectorType;
                logsBloom: ByteVectorType;
                prevRandao: ByteVectorType;
                blockNumber: UintNumberType;
                gasLimit: UintNumberType;
                gasUsed: UintNumberType;
                timestamp: UintNumberType;
                extraData: ByteListType;
                baseFeePerGas: UintBigintType;
                blockHash: ByteVectorType;
                transactions: ListCompositeType<ByteListType>;
                withdrawals: ListCompositeType<ContainerType<{
                index: UintNumberType;
                validatorIndex: UintNumberType;
                address: ExecutionAddressType;
                amount: UintBigintType;
                }>>;
                blobGasUsed: UintBigintType;
                excessBlobGas: UintBigintType;
                blockAccessList: ByteListType;
                slotNumber: UintNumberType;
            }>;
            executionRequests: ContainerType<{
                deposits: ListCompositeType<ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                index: UintBigintType;
                }>>;
                withdrawals: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                validatorPubkey: ByteVectorType;
                amount: UintBigintType;
                }>>;
                consolidations: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                sourcePubkey: ByteVectorType;
                targetPubkey: ByteVectorType;
                }>>;
            }>;
            builderIndex: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            parentBeaconBlockRoot: ByteVectorType;
        }>;
        SignedExecutionPayloadEnvelope: ContainerType<{
            message: ContainerType<{
                payload: ContainerType<{
                    parentHash: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    stateRoot: ByteVectorType;
                    receiptsRoot: ByteVectorType;
                    logsBloom: ByteVectorType;
                    prevRandao: ByteVectorType;
                    blockNumber: UintNumberType;
                    gasLimit: UintNumberType;
                    gasUsed: UintNumberType;
                    timestamp: UintNumberType;
                    extraData: ByteListType;
                    baseFeePerGas: UintBigintType;
                    blockHash: ByteVectorType;
                    transactions: ListCompositeType<ByteListType>;
                    withdrawals: ListCompositeType<ContainerType<{
                    index: UintNumberType;
                    validatorIndex: UintNumberType;
                    address: ExecutionAddressType;
                    amount: UintBigintType;
                    }>>;
                    blobGasUsed: UintBigintType;
                    excessBlobGas: UintBigintType;
                    blockAccessList: ByteListType;
                    slotNumber: UintNumberType;
                }>;
                executionRequests: ContainerType<{
                    deposits: ListCompositeType<ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    index: UintBigintType;
                    }>>;
                    withdrawals: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    validatorPubkey: ByteVectorType;
                    amount: UintBigintType;
                    }>>;
                    consolidations: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    sourcePubkey: ByteVectorType;
                    targetPubkey: ByteVectorType;
                    }>>;
                }>;
                builderIndex: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                parentBeaconBlockRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
        }>;
        BeaconBlockBody: ContainerType<{
            randaoReveal: ByteVectorType;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            graffiti: ByteVectorType;
            proposerSlashings: ListCompositeType<ContainerType<{
            signedHeader1: ContainerType<{
            message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
            }>;
            signedHeader2: ContainerType<{
            message: ContainerType<{
            slot: UintBigintType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            bodyRoot: ByteVectorType;
            }>;
            signature: ByteVectorType;
            }>;
            }>>;
            attesterSlashings: ListCompositeType<ContainerType<{
            attestation1: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>;
            attestation2: ContainerType<{
            attestingIndices: ListBasicType<UintNumberType>;
            data: ContainerType<{
            slot: UintBigintType;
            index: UintBigintType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintBigintType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            }>;
            }>>;
            attestations: ListCompositeType<ContainerType<{
            aggregationBits: BitListType;
            data: ContainerType<{
            slot: UintNumberType;
            index: UintNumberType;
            beaconBlockRoot: ByteVectorType;
            source: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            target: ContainerType<{
            epoch: UintNumberType;
            root: ByteVectorType;
            }>;
            }>;
            signature: ByteVectorType;
            committeeBits: BitVectorType;
            }>>;
            deposits: ListCompositeType<ContainerType<{
            proof: VectorCompositeType<ByteVectorType>;
            data: ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            }>;
            }>>;
            voluntaryExits: ListCompositeType<ContainerType<{
            message: ContainerType<{
            epoch: UintNumberType;
            validatorIndex: UintNumberType;
            }>;
            signature: ByteVectorType;
            }>>;
            syncAggregate: ContainerType<{
                syncCommitteeBits: BitVectorType;
                syncCommitteeSignature: ByteVectorType;
            }>;
            blsToExecutionChanges: ListCompositeType<ContainerType<{
            message: ContainerType<{
            validatorIndex: UintNumberType;
            fromBlsPubkey: ByteVectorType;
            toExecutionAddress: ExecutionAddressType;
            }>;
            signature: ByteVectorType;
            }>>;
            signedExecutionPayloadBid: ContainerType<{
                message: ContainerType<{
                    parentBlockHash: ByteVectorType;
                    parentBlockRoot: ByteVectorType;
                    blockHash: ByteVectorType;
                    prevRandao: ByteVectorType;
                    feeRecipient: ExecutionAddressType;
                    gasLimit: UintBigintType;
                    builderIndex: UintNumberType;
                    slot: UintNumberType;
                    value: UintNumberType;
                    executionPayment: UintNumberType;
                    blobKzgCommitments: ListCompositeType<ByteVectorType>;
                    executionRequestsRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
            }>;
            payloadAttestations: ListCompositeType<ContainerType<{
            aggregationBits: BitVectorType;
            data: ContainerType<{
            beaconBlockRoot: ByteVectorType;
            slot: UintNumberType;
            payloadPresent: BooleanType;
            blobDataAvailable: BooleanType;
            }>;
            signature: ByteVectorType;
            }>>;
            parentExecutionRequests: ContainerType<{
                deposits: ListCompositeType<ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                index: UintBigintType;
                }>>;
                withdrawals: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                validatorPubkey: ByteVectorType;
                amount: UintBigintType;
                }>>;
                consolidations: ListCompositeType<ContainerType<{
                sourceAddress: ExecutionAddressType;
                sourcePubkey: ByteVectorType;
                targetPubkey: ByteVectorType;
                }>>;
            }>;
        }>;
        BeaconBlock: ContainerType<{
            slot: UintNumberType;
            proposerIndex: UintNumberType;
            parentRoot: ByteVectorType;
            stateRoot: ByteVectorType;
            body: ContainerType<{
                randaoReveal: ByteVectorType;
                eth1Data: ContainerType<{
                    depositRoot: ByteVectorType;
                    depositCount: UintNumberType;
                    blockHash: ByteVectorType;
                }>;
                graffiti: ByteVectorType;
                proposerSlashings: ListCompositeType<ContainerType<{
                signedHeader1: ContainerType<{
                message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
                }>;
                signedHeader2: ContainerType<{
                message: ContainerType<{
                slot: UintBigintType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
                }>;
                signature: ByteVectorType;
                }>;
                }>>;
                attesterSlashings: ListCompositeType<ContainerType<{
                attestation1: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>;
                attestation2: ContainerType<{
                attestingIndices: ListBasicType<UintNumberType>;
                data: ContainerType<{
                slot: UintBigintType;
                index: UintBigintType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintBigintType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                }>;
                }>>;
                attestations: ListCompositeType<ContainerType<{
                aggregationBits: BitListType;
                data: ContainerType<{
                slot: UintNumberType;
                index: UintNumberType;
                beaconBlockRoot: ByteVectorType;
                source: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
                }>;
                target: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
                }>;
                }>;
                signature: ByteVectorType;
                committeeBits: BitVectorType;
                }>>;
                deposits: ListCompositeType<ContainerType<{
                proof: VectorCompositeType<ByteVectorType>;
                data: ContainerType<{
                pubkey: ByteVectorType;
                withdrawalCredentials: ByteVectorType;
                amount: UintNumberType;
                signature: ByteVectorType;
                }>;
                }>>;
                voluntaryExits: ListCompositeType<ContainerType<{
                message: ContainerType<{
                epoch: UintNumberType;
                validatorIndex: UintNumberType;
                }>;
                signature: ByteVectorType;
                }>>;
                syncAggregate: ContainerType<{
                    syncCommitteeBits: BitVectorType;
                    syncCommitteeSignature: ByteVectorType;
                }>;
                blsToExecutionChanges: ListCompositeType<ContainerType<{
                message: ContainerType<{
                validatorIndex: UintNumberType;
                fromBlsPubkey: ByteVectorType;
                toExecutionAddress: ExecutionAddressType;
                }>;
                signature: ByteVectorType;
                }>>;
                signedExecutionPayloadBid: ContainerType<{
                    message: ContainerType<{
                        parentBlockHash: ByteVectorType;
                        parentBlockRoot: ByteVectorType;
                        blockHash: ByteVectorType;
                        prevRandao: ByteVectorType;
                        feeRecipient: ExecutionAddressType;
                        gasLimit: UintBigintType;
                        builderIndex: UintNumberType;
                        slot: UintNumberType;
                        value: UintNumberType;
                        executionPayment: UintNumberType;
                        blobKzgCommitments: ListCompositeType<ByteVectorType>;
                        executionRequestsRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                }>;
                payloadAttestations: ListCompositeType<ContainerType<{
                aggregationBits: BitVectorType;
                data: ContainerType<{
                beaconBlockRoot: ByteVectorType;
                slot: UintNumberType;
                payloadPresent: BooleanType;
                blobDataAvailable: BooleanType;
                }>;
                signature: ByteVectorType;
                }>>;
                parentExecutionRequests: ContainerType<{
                    deposits: ListCompositeType<ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    index: UintBigintType;
                    }>>;
                    withdrawals: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    validatorPubkey: ByteVectorType;
                    amount: UintBigintType;
                    }>>;
                    consolidations: ListCompositeType<ContainerType<{
                    sourceAddress: ExecutionAddressType;
                    sourcePubkey: ByteVectorType;
                    targetPubkey: ByteVectorType;
                    }>>;
                }>;
            }>;
        }>;
        SignedBeaconBlock: ContainerType<{
            message: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                body: ContainerType<{
                    randaoReveal: ByteVectorType;
                    eth1Data: ContainerType<{
                        depositRoot: ByteVectorType;
                        depositCount: UintNumberType;
                        blockHash: ByteVectorType;
                    }>;
                    graffiti: ByteVectorType;
                    proposerSlashings: ListCompositeType<ContainerType<{
                    signedHeader1: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    signedHeader2: ContainerType<{
                    message: ContainerType<{
                    slot: UintBigintType;
                    proposerIndex: UintNumberType;
                    parentRoot: ByteVectorType;
                    stateRoot: ByteVectorType;
                    bodyRoot: ByteVectorType;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attesterSlashings: ListCompositeType<ContainerType<{
                    attestation1: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    attestation2: ContainerType<{
                    attestingIndices: ListBasicType<UintNumberType>;
                    data: ContainerType<{
                    slot: UintBigintType;
                    index: UintBigintType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintBigintType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    attestations: ListCompositeType<ContainerType<{
                    aggregationBits: BitListType;
                    data: ContainerType<{
                    slot: UintNumberType;
                    index: UintNumberType;
                    beaconBlockRoot: ByteVectorType;
                    source: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    target: ContainerType<{
                    epoch: UintNumberType;
                    root: ByteVectorType;
                    }>;
                    }>;
                    signature: ByteVectorType;
                    committeeBits: BitVectorType;
                    }>>;
                    deposits: ListCompositeType<ContainerType<{
                    proof: VectorCompositeType<ByteVectorType>;
                    data: ContainerType<{
                    pubkey: ByteVectorType;
                    withdrawalCredentials: ByteVectorType;
                    amount: UintNumberType;
                    signature: ByteVectorType;
                    }>;
                    }>>;
                    voluntaryExits: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    epoch: UintNumberType;
                    validatorIndex: UintNumberType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    syncAggregate: ContainerType<{
                        syncCommitteeBits: BitVectorType;
                        syncCommitteeSignature: ByteVectorType;
                    }>;
                    blsToExecutionChanges: ListCompositeType<ContainerType<{
                    message: ContainerType<{
                    validatorIndex: UintNumberType;
                    fromBlsPubkey: ByteVectorType;
                    toExecutionAddress: ExecutionAddressType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    signedExecutionPayloadBid: ContainerType<{
                        message: ContainerType<{
                            parentBlockHash: ByteVectorType;
                            parentBlockRoot: ByteVectorType;
                            blockHash: ByteVectorType;
                            prevRandao: ByteVectorType;
                            feeRecipient: ExecutionAddressType;
                            gasLimit: UintBigintType;
                            builderIndex: UintNumberType;
                            slot: UintNumberType;
                            value: UintNumberType;
                            executionPayment: UintNumberType;
                            blobKzgCommitments: ListCompositeType<ByteVectorType>;
                            executionRequestsRoot: ByteVectorType;
                        }>;
                        signature: ByteVectorType;
                    }>;
                    payloadAttestations: ListCompositeType<ContainerType<{
                    aggregationBits: BitVectorType;
                    data: ContainerType<{
                    beaconBlockRoot: ByteVectorType;
                    slot: UintNumberType;
                    payloadPresent: BooleanType;
                    blobDataAvailable: BooleanType;
                    }>;
                    signature: ByteVectorType;
                    }>>;
                    parentExecutionRequests: ContainerType<{
                        deposits: ListCompositeType<ContainerType<{
                        pubkey: ByteVectorType;
                        withdrawalCredentials: ByteVectorType;
                        amount: UintNumberType;
                        signature: ByteVectorType;
                        index: UintBigintType;
                        }>>;
                        withdrawals: ListCompositeType<ContainerType<{
                        sourceAddress: ExecutionAddressType;
                        validatorPubkey: ByteVectorType;
                        amount: UintBigintType;
                        }>>;
                        consolidations: ListCompositeType<ContainerType<{
                        sourceAddress: ExecutionAddressType;
                        sourcePubkey: ByteVectorType;
                        targetPubkey: ByteVectorType;
                        }>>;
                    }>;
                }>;
            }>;
            signature: ByteVectorType;
        }>;
        BeaconState: ContainerType<{
            genesisTime: UintNumberType;
            genesisValidatorsRoot: ByteVectorType;
            slot: UintNumberType;
            fork: ContainerType<{
                previousVersion: ByteVectorType;
                currentVersion: ByteVectorType;
                epoch: UintNumberType;
            }>;
            latestBlockHeader: ContainerType<{
                slot: UintNumberType;
                proposerIndex: UintNumberType;
                parentRoot: ByteVectorType;
                stateRoot: ByteVectorType;
                bodyRoot: ByteVectorType;
            }>;
            blockRoots: VectorCompositeType<ByteVectorType>;
            stateRoots: VectorCompositeType<ByteVectorType>;
            historicalRoots: ListCompositeType<ByteVectorType>;
            eth1Data: ContainerType<{
                depositRoot: ByteVectorType;
                depositCount: UintNumberType;
                blockHash: ByteVectorType;
            }>;
            eth1DataVotes: ListCompositeType<ContainerType<{
            depositRoot: ByteVectorType;
            depositCount: UintNumberType;
            blockHash: ByteVectorType;
            }>>;
            eth1DepositIndex: UintNumberType;
            validators: ListCompositeType<ValidatorNodeStructType>;
            balances: ListUintNum64Type;
            randaoMixes: VectorCompositeType<ByteVectorType>;
            slashings: VectorBasicType<UintNumberType>;
            previousEpochParticipation: ListBasicType<UintNumberType>;
            currentEpochParticipation: ListBasicType<UintNumberType>;
            justificationBits: BitVectorType;
            previousJustifiedCheckpoint: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            currentJustifiedCheckpoint: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            finalizedCheckpoint: ContainerType<{
                epoch: UintNumberType;
                root: ByteVectorType;
            }>;
            inactivityScores: ListBasicType<UintNumberType>;
            currentSyncCommittee: ContainerType<{
                pubkeys: VectorCompositeType<ByteVectorType>;
                aggregatePubkey: ByteVectorType;
            }>;
            nextSyncCommittee: ContainerType<{
                pubkeys: VectorCompositeType<ByteVectorType>;
                aggregatePubkey: ByteVectorType;
            }>;
            latestBlockHash: ByteVectorType;
            nextWithdrawalIndex: UintNumberType;
            nextWithdrawalValidatorIndex: UintNumberType;
            historicalSummaries: ListCompositeType<ContainerType<{
            blockSummaryRoot: ByteVectorType;
            stateSummaryRoot: ByteVectorType;
            }>>;
            depositRequestsStartIndex: UintBigintType;
            depositBalanceToConsume: UintBigintType;
            exitBalanceToConsume: UintBigintType;
            earliestExitEpoch: UintNumberType;
            consolidationBalanceToConsume: UintBigintType;
            earliestConsolidationEpoch: UintNumberType;
            pendingDeposits: ListCompositeType<ContainerType<{
            pubkey: ByteVectorType;
            withdrawalCredentials: ByteVectorType;
            amount: UintNumberType;
            signature: ByteVectorType;
            slot: UintNumberType;
            }>>;
            pendingPartialWithdrawals: ListCompositeType<ContainerType<{
            validatorIndex: UintNumberType;
            amount: UintBigintType;
            withdrawableEpoch: UintNumberType;
            }>>;
            pendingConsolidations: ListCompositeType<ContainerType<{
            sourceIndex: UintNumberType;
            targetIndex: UintNumberType;
            }>>;
            proposerLookahead: VectorBasicType<UintNumberType>;
            builders: ListCompositeType<ContainerType<{
            pubkey: ByteVectorType;
            version: UintNumberType;
            executionAddress: ExecutionAddressType;
            balance: UintNumberType;
            depositEpoch: UintNumberType;
            withdrawableEpoch: UintNumberType;
            }>>;
            nextWithdrawalBuilderIndex: UintNumberType;
            executionPayloadAvailability: BitVectorType;
            builderPendingPayments: VectorCompositeType<ContainerType<{
            weight: UintNumberType;
            withdrawal: ContainerType<{
            feeRecipient: ExecutionAddressType;
            amount: UintNumberType;
            builderIndex: UintNumberType;
            }>;
            }>>;
            builderPendingWithdrawals: ListCompositeType<ContainerType<{
            feeRecipient: ExecutionAddressType;
            amount: UintNumberType;
            builderIndex: UintNumberType;
            }>>;
            latestExecutionPayloadBid: ContainerType<{
                parentBlockHash: ByteVectorType;
                parentBlockRoot: ByteVectorType;
                blockHash: ByteVectorType;
                prevRandao: ByteVectorType;
                feeRecipient: ExecutionAddressType;
                gasLimit: UintBigintType;
                builderIndex: UintNumberType;
                slot: UintNumberType;
                value: UintNumberType;
                executionPayment: UintNumberType;
                blobKzgCommitments: ListCompositeType<ByteVectorType>;
                executionRequestsRoot: ByteVectorType;
            }>;
            payloadExpectedWithdrawals: ListCompositeType<ContainerType<{
            index: UintNumberType;
            validatorIndex: UintNumberType;
            address: ExecutionAddressType;
            amount: UintBigintType;
            }>>;
            ptcWindow: VectorCompositeType<VectorBasicType<UintNumberType>>;
        }>;
        DataColumnSidecar: ContainerType<{
            index: UintNumberType;
            column: ListCompositeType<ByteVectorType>;
            kzgProofs: ListCompositeType<ByteVectorType>;
            slot: UintNumberType;
            beaconBlockRoot: ByteVectorType;
        }>;
        DataColumnSidecars: ListCompositeType<ContainerType<{
        index: UintNumberType;
        column: ListCompositeType<ByteVectorType>;
        kzgProofs: ListCompositeType<ByteVectorType>;
        slot: UintNumberType;
        beaconBlockRoot: ByteVectorType;
        }>>;
        ExecutionPayloadEnvelopesByRangeRequest: ContainerType<{
            startSlot: UintNumberType;
            count: UintNumberType;
        }>;
        PayloadAttributes: ContainerType<{
            timestamp: UintNumberType;
            prevRandao: ByteVectorType;
            suggestedFeeRecipient: StringType<string>;
            withdrawals: ListCompositeType<ContainerType<{
            index: UintNumberType;
            validatorIndex: UintNumberType;
            address: ExecutionAddressType;
            amount: UintBigintType;
            }>>;
            parentBeaconBlockRoot: ByteVectorType;
            slotNumber: UintNumberType;
        }>;
        SSEPayloadAttributes: ContainerType<{
            proposerIndex: UintNumberType;
            proposalSlot: UintNumberType;
            parentBlockNumber: UintNumberType;
            parentBlockRoot: ByteVectorType;
            parentBlockHash: ByteVectorType;
            payloadAttributes: ContainerType<{
                timestamp: UintNumberType;
                prevRandao: ByteVectorType;
                suggestedFeeRecipient: StringType<string>;
                withdrawals: ListCompositeType<ContainerType<{
                index: UintNumberType;
                validatorIndex: UintNumberType;
                address: ExecutionAddressType;
                amount: UintBigintType;
                }>>;
                parentBeaconBlockRoot: ByteVectorType;
                slotNumber: UintNumberType;
            }>;
        }>;
    };
};

declare const Uint16: UintNumberType;

declare const Uint32: UintNumberType;

declare const Uint8: UintNumberType;

declare type UintBigintByteLen = 1 | 2 | 4 | 8 | 16 | 32;

declare interface UintBigintOpts {
    typeName?: string;
}

/**
 * Uint: N-bit unsigned integer (where N in [8, 16, 32, 64, 128, 256])
 * - Notation: uintN
 *
 * UintBigint is represented as the Javascript primitive value 'BigInt'.
 *
 * The BigInt type is a numeric primitive in JavaScript that can represent integers with arbitrary precision.
 * With BigInts, you can safely store and operate on large integers even beyond the safe integer limit for Numbers.
 *
 * As of 2021 performance of 'Number' is extremely faster than 'BigInt'. For Uint values under 53 bits use UintNumber.
 * For other values that may exceed 53 bits, use UintBigint.
 */
declare class UintBigintType extends BasicType<bigint> {
    readonly byteLength: UintBigintByteLen;
    readonly typeName: string;
    readonly itemsPerChunk: number;
    readonly fixedSize: number;
    readonly minSize: number;
    readonly maxSize: number;
    constructor(byteLength: UintBigintByteLen, opts?: UintBigintOpts);
    static named(byteLength: UintBigintByteLen, opts: Require<UintBigintOpts, "typeName">): UintBigintType;
    defaultValue(): bigint;
    value_serializeToBytes({ dataView }: ByteViews, offset: number, value: bigint): number;
    value_deserializeFromBytes({ dataView }: ByteViews, start: number, end: number): bigint;
    tree_serializeToBytes(output: ByteViews, offset: number, node: Node_2): number;
    tree_deserializeFromBytes(data: ByteViews, start: number, end: number): Node_2;
    tree_getFromNode(leafNode: LeafNode): bigint;
    /** Mutates node to set value */
    tree_setToNode(leafNode: LeafNode, value: bigint): void;
    /** EXAMPLE of `tree_getFromNode` */
    tree_getFromPackedNode(leafNode: LeafNode, index: number): bigint;
    /** Mutates node to set value */
    tree_setToPackedNode(leafNode: LeafNode, index: number, value: bigint): void;
    fromJson(json: unknown): bigint;
    toJson(value: bigint): unknown;
}

declare const UintBn128: UintBigintType;

declare const UintBn256: UintBigintType;

declare const UintBn64: UintBigintType;

declare type UintBn64_2 = ValueOf<typeof ssz.UintBn64>;

/**
 * A JS `number` is an IEEE-754 double which has 53 bits integer precision. This implies that it can store
 * a value up to 2^53-1 without losing any precision (`Number.MAX_SAFE_INTEGER` represents that exact limit).
 * So it can't store a 64 bit integer with precision in the higher bits.
 *
 * However, JS `bigint` arithmetics is ~100x slower than `number`.
 * Therefor, this type uses `number` for 64 bits values, for use in well-analyzed cases where
 * the value is known to never cross the `Number.MAX_SAFE_INTEGER` limit.
 *
 * Caution and reasoned analysis are always required before using this type as the consequence of misuse is a consensus split.
 */
declare const UintNum64: UintNumberType;

declare type UintNum64_2 = ValueOf<typeof ssz.UintNum64>;

declare type UintNumberByteLen = 1 | 2 | 4 | 8;

declare interface UintNumberOpts {
    /** Represent the value 2^64-1 as the symbolic value `+Infinity`. @see UintNumberType for a justification. */
    clipInfinity?: boolean;
    /** For `tree_setToPackedNode` set values with bitwise OR instead of a regular set */
    setBitwiseOR?: boolean;
    typeName?: string;
}

/**
 * Uint: N-bit unsigned integer (where N in [8, 16, 32, 64, 128, 256])
 * - Notation: uintN
 *
 * UintNumber is represented as the Javascript primitive value 'Number'.
 *
 * The Number type is a double-precision 64-bit binary format IEEE 754 value (numbers between -(2^53 − 1) and
 * 2^53 − 1). It also has the symbolic value: +Infinity.
 *
 * As of 2021 performance of 'Number' is extremely faster than 'BigInt'. Some values are spec'ed as Uint64 but
 * practically they will never exceed 53 bits, such as any unit time or simple counters. This type is an optimization
 * for these cases, as UintNumber64 can represent any value between 0 and 2^53−1 as well as the max value 2^64-1.
 */
declare class UintNumberType extends BasicType<number> {
    readonly byteLength: UintNumberByteLen;
    readonly typeName: string;
    readonly itemsPerChunk: number;
    readonly fixedSize: number;
    readonly minSize: number;
    readonly maxSize: number;
    private readonly maxDecimalStr;
    private readonly clipInfinity;
    private readonly setBitwiseOR;
    constructor(byteLength: UintNumberByteLen, opts?: UintNumberOpts);
    static named(byteLength: UintNumberByteLen, opts: Require<UintNumberOpts, "typeName">): UintNumberType;
    defaultValue(): number;
    value_serializeToBytes({ dataView }: ByteViews, offset: number, value: number): number;
    value_deserializeFromBytes({ dataView }: ByteViews, start: number, end: number): number;
    value_toTree(value: number): Node_2;
    tree_serializeToBytes(output: ByteViews, offset: number, node: Node_2): number;
    tree_deserializeFromBytes(data: ByteViews, start: number, end: number): Node_2;
    tree_getFromNode(leafNode: LeafNode): number;
    tree_setToNode(leafNode: LeafNode, value: number): void;
    tree_getFromPackedNode(leafNode: LeafNode, index: number): number;
    tree_setToPackedNode(leafNode: LeafNode, index: number, value: number): void;
    fromJson(json: unknown): number;
    toJson(value: number): unknown;
}

declare type UintNumInf64 = ValueOf<typeof ssz.UintNumInf64>;

declare const UintNumInf64_2: UintNumberType;

/**
 * A type of union of forks must accept as any parameter the UNION of all fork types.
 */
declare type UnionSSZForksTypeOf<UnionOfForkTypes extends ContainerType<any>> = CompositeType<ValueOf<UnionOfForkTypes>, CompositeView<UnionOfForkTypes>, CompositeViewDU<UnionOfForkTypes>>;

export declare function upgradeLightClientFinalityUpdate(config: ChainForkConfig, targetFork: ForkName, finalityUpdate: LightClientFinalityUpdate): LightClientFinalityUpdate;

export declare function upgradeLightClientOptimisticUpdate(config: ChainForkConfig, targetFork: ForkName, optimisticUpdate: LightClientOptimisticUpdate_9): LightClientOptimisticUpdate_9;

declare type UrlInitRequired = ApiRequestInit & {
    urlIndex: number;
    baseUrl: string;
    /** Used in logs and metrics to prevent leaking user credentials */
    printableUrl: string;
};

declare namespace utils {
    export {
        getApiFromUrl,
        getChainForkConfigFromNetwork,
        chunkifyInclusiveRange,
        getCurrentSlot,
        slotWithFutureTolerance,
        computeEpochAtSlot,
        computeSyncPeriodAtSlot,
        computeSyncPeriodAtEpoch,
        timeUntilNextEpoch,
        computeDomain,
        getForkVersion,
        computeForkDataRoot,
        computeSigningRoot,
        getConsoleLogger,
        LogHandler,
        ILcLogger,
        getLcLoggerConsole,
        isBetterUpdate,
        LightclientUpdateStats,
        sumBits,
        isZeroHash,
        assertZeroHashes,
        getParticipantPubkeys,
        toBlockHeader,
        deserializeSyncCommittee,
        serializeSyncCommittee,
        isEmptyHeader,
        getGenesisData,
        getFinalizedSyncCheckpoint,
        isNode,
        isValidMerkleBranch,
        SYNC_COMMITTEES_DEPTH,
        SYNC_COMMITTEES_INDEX
    }
}
export { utils }

declare namespace validation {
    export {
        assertValidLightClientUpdate,
        assertValidFinalityProof,
        assertValidSyncCommitteeProof,
        assertValidSignedHeader
    }
}
export { validation }

declare const Validator: ValidatorNodeStructType;

declare namespace validator {
    export {
        getDefinitions_13 as getDefinitions,
        BuilderSelection,
        ExtraProduceBlockOpts,
        ProduceBlockV3MetaType,
        ProduceBlockV3Meta,
        ProduceBlockV4MetaType,
        ProduceBlockV4Meta,
        AttesterDutyType,
        ProposerDutyType,
        PtcDutyType,
        SyncDutyType,
        BeaconCommitteeSubscriptionType,
        SyncCommitteeSubscriptionType,
        ProposerPreparationDataType,
        BeaconCommitteeSelectionType,
        SyncCommitteeSelectionType,
        LivenessResponseDataType,
        ValidatorIndicesType,
        AttesterDutyListType,
        ProposerDutyListType,
        PtcDutyListType,
        SyncDutyListType,
        SignedAggregateAndProofListPhase0Type,
        SignedAggregateAndProofListElectraType,
        SignedContributionAndProofListType,
        BeaconCommitteeSubscriptionListType,
        SyncCommitteeSubscriptionListType,
        ProposerPreparationDataListType,
        BeaconCommitteeSelectionListType,
        SyncCommitteeSelectionListType,
        LivenessResponseDataListType,
        SignedValidatorRegistrationV1ListType,
        ValidatorIndices,
        AttesterDuty,
        AttesterDutyList,
        ProposerDuty,
        ProposerDutyList,
        PtcDuty,
        PtcDutyList,
        SyncDuty,
        SyncDutyList,
        SignedAggregateAndProofListPhase0,
        SignedAggregateAndProofListElectra,
        SignedAggregateAndProofList,
        SignedContributionAndProofList,
        BeaconCommitteeSubscription,
        BeaconCommitteeSubscriptionList,
        SyncCommitteeSubscription,
        SyncCommitteeSubscriptionList,
        ProposerPreparationData,
        ProposerPreparationDataList,
        BeaconCommitteeSelection,
        BeaconCommitteeSelectionList,
        SyncCommitteeSelection,
        SyncCommitteeSelectionList,
        LivenessResponseData,
        LivenessResponseDataList,
        SignedValidatorRegistrationV1List,
        Endpoints_14 as Endpoints
    }
}

declare type Validator_2 = ValueOf<typeof ssz_2.Validator>;

declare type ValidatorBalance = ValueOf<typeof ValidatorBalanceType>;

declare type ValidatorBalanceList = ValueOf<typeof ValidatorBalanceListType>;

declare const ValidatorBalanceListType: ArrayType<Type<ValueOfFields<    {
index: UintNumberType;
balance: UintNumberType;
}>>, unknown, unknown>;

declare const ValidatorBalanceType: ContainerType<{
    index: UintNumberType;
    balance: UintNumberType;
}>;

declare type ValidatorId = string | number;

declare type ValidatorIdentities = ValueOf<typeof ValidatorIdentitiesType>;

declare const ValidatorIdentitiesType: ArrayType<Type<ValueOfFields<    {
index: UintNumberType;
pubkey: ByteVectorType;
activationEpoch: UintNumberType;
}>>, unknown, unknown>;

declare const ValidatorIdentityType: ContainerType<{
    index: UintNumberType;
    pubkey: ByteVectorType;
    activationEpoch: UintNumberType;
}>;

/**
 * Use JS Number for performance, values must be limited to 2**52-1.
 * ValidatorIndex is bounded by `VALIDATOR_REGISTRY_LIMIT`
 */
declare const ValidatorIndex: UintNumberType;

declare type ValidatorIndex_2 = UintNum64_2;

declare type ValidatorIndices = ValueOf<typeof ValidatorIndicesType>;

declare const ValidatorIndicesType: ArrayType<Type<number>, unknown, unknown>;

/**
 * Improve serialization performance for state.validators.serialize();
 */
declare class ValidatorNodeStructType extends ContainerNodeStructType<typeof ValidatorType> {
    constructor();
    value_serializeToBytes({ uint8Array: output, dataView }: ByteViews, offset: number, validator: ValueOfFields<typeof ValidatorType>): number;
}

declare const ValidatorRegistrationV1: ContainerType<{
    feeRecipient: ExecutionAddressType;
    gasLimit: UintNumberType;
    timestamp: UintNumberType;
    pubkey: ByteVectorType;
}>;

declare type ValidatorRegistrationV1_2 = ValueOf<typeof ssz_4.ValidatorRegistrationV1>;

declare type ValidatorResponse = ValueOf<typeof ValidatorResponseType>;

declare type ValidatorResponseList = ValueOf<typeof ValidatorResponseListType>;

declare const ValidatorResponseListType: ArrayType<Type<ValueOfFields<    {
index: UintNumberType;
balance: UintNumberType;
status: StringType<ValidatorStatus>;
validator: ValidatorNodeStructType;
}>>, unknown, unknown>;

declare const ValidatorResponseType: ContainerType<{
    index: UintNumberType;
    balance: UintNumberType;
    status: StringType<ValidatorStatus>;
    validator: ValidatorNodeStructType;
}>;

declare const Validators: ListCompositeType<ValidatorNodeStructType>;

declare type Validators_2 = ValueOf<typeof ssz_2.Validators>;

/**
 * [Validator status specification](https://hackmd.io/ofFJ5gOmQpu1jjHilHbdQQ)
 */
declare type ValidatorStatus = "pending_initialized" | "pending_queued" | "active_ongoing" | "active_exiting" | "active_slashed" | "exited_unslashed" | "exited_slashed" | "withdrawal_possible" | "withdrawal_done";

declare const ValidatorType: {
    pubkey: ByteVectorType;
    withdrawalCredentials: ByteVectorType;
    effectiveBalance: UintNumberType;
    slashed: BooleanType;
    activationEligibilityEpoch: UintNumberType;
    activationEpoch: UintNumberType;
    exitEpoch: UintNumberType;
    withdrawableEpoch: UintNumberType;
};

declare type ValueOf<T extends Type<unknown>> = T extends Type<infer V> ? V : never;

declare type ValueOfFields<Fields extends Record<string, Type<unknown>>> = {
    [K in keyof Fields]: ValueOf<Fields[K]>;
};

declare type ValueOfType<ElementType extends Type<unknown>> = ElementType extends Type<infer T> ? T | null : never;

declare type VectorBasicOpts = {
    typeName?: string;
};

/**
 * Vector: Ordered fixed-length homogeneous collection, with N values
 *
 * Array of Basic type:
 * - Basic types are max 32 bytes long so multiple values may be packed in the same node.
 * - Basic types are never returned in a view wrapper, but their value representation
 */
declare class VectorBasicType<ElementType extends BasicType<unknown>> extends ArrayType<ElementType, ArrayBasicTreeView<ElementType>, ArrayBasicTreeViewDU<ElementType>> implements ArrayBasicType<ElementType> {
    readonly elementType: ElementType;
    readonly length: number;
    readonly typeName: string;
    readonly itemsPerChunk: number;
    readonly depth: number;
    readonly chunkDepth: number;
    readonly maxChunkCount: number;
    readonly fixedSize: number;
    readonly minSize: number;
    readonly maxSize: number;
    readonly isList = false;
    readonly isViewMutable = true;
    protected readonly defaultLen: number;
    constructor(elementType: ElementType, length: number, opts?: VectorBasicOpts);
    static named<ElementType extends BasicType<unknown>>(elementType: ElementType, limit: number, opts: Require<VectorBasicOpts, "typeName">): VectorBasicType<ElementType>;
    getView(tree: Tree): ArrayBasicTreeView<ElementType>;
    toView(value: ArrayLike_2<ValueOf<ElementType>>): ArrayBasicTreeView<ElementType>;
    getViewDU(node: Node_2, cache?: unknown): ArrayBasicTreeViewDU<ElementType>;
    commitView(view: ArrayBasicTreeView<ElementType>): Node_2;
    commitViewDU(view: ArrayBasicTreeViewDU<ElementType>, hcOffset?: number, hcByLevel?: HashComputationLevel[] | null): Node_2;
    cacheOfViewDU(view: ArrayBasicTreeViewDU<ElementType>): unknown;
    toViewDU(value: ArrayLike_2<ValueOf<ElementType>>): ArrayBasicTreeViewDU<ElementType>;
    value_serializedSize(): number;
    value_serializeToBytes(output: ByteViews, offset: number, value: ValueOf<ElementType>[]): number;
    value_deserializeFromBytes(data: ByteViews, start: number, end: number): ValueOf<ElementType>[];
    tree_serializedSize(): number;
    tree_serializeToBytes(output: ByteViews, offset: number, node: Node_2): number;
    tree_deserializeFromBytes(data: ByteViews, start: number, end: number): Node_2;
    tree_getLength(): number;
    tree_setLength(): void;
    tree_getChunksNode(node: Node_2): Node_2;
    tree_chunksNodeOffset(): number;
    tree_setChunksNode(_rootNode: Node_2, chunksNode: Node_2): Node_2;
    protected getBlocksBytes(value: ValueOf<ElementType>[]): Uint8Array;
}

declare type VectorCompositeOpts = {
    typeName?: string;
};

/**
 * Vector: Ordered fixed-length homogeneous collection, with N values
 *
 * Array of Composite type:
 * - Composite types always take at least one chunk
 * - Composite types are always returned as views
 */
declare class VectorCompositeType<ElementType extends CompositeType<any, CompositeView<ElementType>, CompositeViewDU<ElementType>>> extends ArrayType<ElementType, ArrayCompositeTreeView<ElementType>, ArrayCompositeTreeViewDU<ElementType>> implements ArrayCompositeType<ElementType> {
    readonly elementType: ElementType;
    readonly length: number;
    readonly typeName: string;
    readonly itemsPerChunk = 1;
    readonly depth: number;
    readonly chunkDepth: number;
    readonly maxChunkCount: number;
    readonly fixedSize: number | null;
    readonly minSize: number;
    readonly maxSize: number;
    readonly isList = false;
    readonly isViewMutable = true;
    protected readonly defaultLen: number;
    constructor(elementType: ElementType, length: number, opts?: VectorCompositeOpts);
    static named<ElementType extends CompositeType<unknown, CompositeView<ElementType>, CompositeViewDU<ElementType>>>(elementType: ElementType, limit: number, opts: Require<VectorCompositeOpts, "typeName">): VectorCompositeType<ElementType>;
    getView(tree: Tree): ArrayCompositeTreeView<ElementType>;
    toView(value: ValueOf<ElementType>[]): ArrayCompositeTreeView<ElementType>;
    toView(value: ArrayLike_2<CompositeElementInput<ElementType>>): ArrayCompositeTreeView<ElementType>;
    getViewDU(node: Node_2, cache?: unknown): ArrayCompositeTreeViewDU<ElementType>;
    toViewDU(value: ValueOf<ElementType>[]): ArrayCompositeTreeViewDU<ElementType>;
    toViewDU(value: ArrayLike_2<CompositeElementInput<ElementType>>): ArrayCompositeTreeViewDU<ElementType>;
    commitView(view: ArrayCompositeTreeView<ElementType>): Node_2;
    commitViewDU(view: ArrayCompositeTreeViewDU<ElementType>, hcOffset?: number, hcByLevel?: HashComputationLevel[] | null): Node_2;
    cacheOfViewDU(view: ArrayCompositeTreeViewDU<ElementType>): unknown;
    value_serializedSize(value: ValueOf<ElementType>[]): number;
    value_serializeToBytes(output: ByteViews, offset: number, value: ValueOf<ElementType>[]): number;
    value_deserializeFromBytes(data: ByteViews, start: number, end: number, reuseBytes?: boolean): ValueOf<ElementType>[];
    tree_serializedSize(node: Node_2): number;
    tree_serializeToBytes(output: ByteViews, offset: number, node: Node_2): number;
    tree_deserializeFromBytes(data: ByteViews, start: number, end: number): Node_2;
    tree_getLength(): number;
    tree_setLength(): void;
    tree_getChunksNode(node: Node_2): Node_2;
    tree_chunksNodeOffset(): number;
    tree_setChunksNode(_rootNode: Node_2, chunksNode: Node_2): Node_2;
    protected getBlocksBytes(value: ValueOf<ElementType>[]): Uint8Array;
}

declare const Version: ByteVectorType;

declare type Version_2 = Bytes4_2;

declare const VersionedHash: ByteVectorType;

declare type VersionMeta = ValueOf<typeof VersionType>;

declare const VersionType: ContainerType<{
    /**
     * Fork code name
     */
    version: StringType<ForkName>;
}>;

declare const VoluntaryExit: ContainerType<{
    epoch: UintNumberType;
    validatorIndex: UintNumberType;
}>;

declare type VoluntaryExit_2 = ValueOf<typeof ssz_2.VoluntaryExit>;

declare const Wei: UintBigintType;

declare enum WireFormat {
    json = "json",
    ssz = "ssz"
}

declare type Withdrawal = ValueOf<typeof ssz_5.Withdrawal>;

declare const Withdrawal_2: ContainerType<{
    index: UintNumberType;
    validatorIndex: UintNumberType;
    address: ExecutionAddressType;
    amount: UintBigintType;
}>;

declare const WithdrawalIndex: UintNumberType;

declare const WithdrawalRequest: ContainerType<{
    sourceAddress: ExecutionAddressType;
    validatorPubkey: ByteVectorType;
    amount: UintBigintType;
}>;

declare type WithdrawalRequest_2 = ValueOf<typeof ssz_7.WithdrawalRequest>;

declare const WithdrawalRequests: ListCompositeType<ContainerType<{
    sourceAddress: ExecutionAddressType;
    validatorPubkey: ByteVectorType;
    amount: UintBigintType;
}>>;

declare type WithdrawalRequests_2 = ValueOf<typeof ssz_7.WithdrawalRequests>;

declare const Withdrawals: ListCompositeType<ContainerType<{
    index: UintNumberType;
    validatorIndex: UintNumberType;
    address: ExecutionAddressType;
    amount: UintBigintType;
}>>;

declare type Withdrawals_2 = ValueOf<typeof ssz_5.Withdrawals>;

export { }