@northstake/northstakeapi 1.0.40 → 1.0.41

package/api.ts

@@ -9,6 +9,7 @@ import { LidoWriteApi } from './api/lidoWriteApi';
 import { LinkedWalletsApi } from './api/linkedWalletsApi';
 import { OrganizationApi } from './api/organizationApi';
 import { ValidatorsApi } from './api/validatorsApi';
+export * from './model/./abandonDashboardRequest';
 export * from './model/./acceptedQuote';
 export * from './model/./accountEntity';
 export * from './model/./addLinkedWalletRequest';
@@ -49,9 +50,9 @@ export * from './model/./getLazyOracleReportCallData200ResponseDestructuredCalld
 export * from './model/./getLazyOracleReportData200Response';
 export * from './model/./getLazyOracleReportData200ResponseReportData';
 export * from './model/./getLidoTransactions200Response';
+export * from './model/./getOperatorGroup200Response';
 export * from './model/./getQuarantineInfo200Response';
 export * from './model/./getStETHPerWstETHRate200Response';
-export * from './model/./getWithdrawalsResponse';
 export * from './model/./grantRole';
 export * from './model/./internalTransaction';
 export * from './model/./inviteMemberRequest';
@@ -117,7 +118,6 @@ export * from './model/./validatorRewardsDaily';
 export * from './model/./validatorRewardsDailyResponse';
 export * from './model/./validatorRewardsRaw';
 export * from './model/./validatorType';
-export * from './model/./validatorWithdrawal';
 export * from './model/./vaultCreationStartResponse';
 export * from './model/./wallet';
 export * from './model/./webHookLookupAnswer';

package/dist/api/lidoReadApi.d.ts

@@ -11,6 +11,7 @@
  */
 import { GetLazyOracleReportData200Response } from '../model/getLazyOracleReportData200Response';
 import { GetLidoTransactions200Response } from '../model/getLidoTransactions200Response';
+import { GetOperatorGroup200Response } from '../model/getOperatorGroup200Response';
 import { GetQuarantineInfo200Response } from '../model/getQuarantineInfo200Response';
 import { GetStETHPerWstETHRate200Response } from '../model/getStETHPerWstETHRate200Response';
 import { Authentication, Interceptor } from '../model/models';
@@ -95,6 +96,19 @@ export declare class LidoReadApi {
         body: GetLidoTransactions200Response;
         status: number;
     }>;
+    /**
+     *
+     * @summary Get operator group info from the operator grid
+     * @param nodeOperator The Ethereum address of the node operator
+     */
+    getOperatorGroup(nodeOperator: string, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<{
+        body: GetOperatorGroup200Response;
+        status: number;
+    }>;
     /**
      *
      * @summary Get quarantine info for a vault

package/dist/api/lidoReadApi.js

@@ -290,6 +290,75 @@ class LidoReadApi {
             });
         });
     }
+    /**
+     *
+     * @summary Get operator group info from the operator grid
+     * @param nodeOperator The Ethereum address of the node operator
+     */
+    async getOperatorGroup(nodeOperator, options = { headers: {} }) {
+        const localVarPath = this.basePath + '/lidov3/operator-group';
+        let localVarQueryParameters = {};
+        let localVarHeaderParams = Object.assign({}, this._defaultHeaders);
+        const produces = ['application/json'];
+        if (produces.indexOf('application/json') >= 0) {
+            localVarHeaderParams.Accept = 'application/json';
+        }
+        else {
+            localVarHeaderParams.Accept = produces.join(',');
+        }
+        let localVarFormParams = {};
+        // Verify required parameter 'nodeOperator' is not null or undefined
+        if (nodeOperator === null || nodeOperator === undefined) {
+            throw new Error('Required parameter "nodeOperator" was null or undefined when calling getOperatorGroup.');
+        }
+        if (nodeOperator !== undefined) {
+            localVarQueryParameters['nodeOperator'] = models_1.ObjectSerializer.serialize(nodeOperator, "string");
+        }
+        Object.assign(localVarHeaderParams, options.headers);
+        let localVarUseFormData = false;
+        let localVarRequestOptions = {
+            method: 'GET',
+            qs: localVarQueryParameters,
+            headers: localVarHeaderParams,
+            uri: localVarPath,
+            useQuerystring: this._useQuerystring,
+            json: true,
+        };
+        let authenticationPromise = Promise.resolve();
+        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
+        let interceptorPromise = authenticationPromise;
+        for (const interceptor of this.interceptors) {
+            interceptorPromise = interceptorPromise.then(() => interceptor(localVarRequestOptions));
+        }
+        return interceptorPromise.then(() => {
+            if (Object.keys(localVarFormParams).length) {
+                if (localVarUseFormData) {
+                    localVarRequestOptions.formData = localVarFormParams;
+                }
+                else {
+                    localVarRequestOptions.form = localVarFormParams;
+                }
+            }
+            return new Promise((resolve, reject) => {
+                (0, request_1.default)(localVarRequestOptions, (error, response, body) => {
+                    if (error) {
+                        console.error('API call error:', error);
+                        reject(error);
+                    }
+                    else {
+                        if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
+                            body = models_1.ObjectSerializer.deserialize(body, "GetOperatorGroup200Response");
+                            resolve({ body: body, status: response.statusCode });
+                        }
+                        else {
+                            console.error('API response error:', response.statusCode);
+                            resolve({ body: body, status: response.statusCode });
+                        }
+                    }
+                });
+            });
+        });
+    }
     /**
      *
      * @summary Get quarantine info for a vault

package/dist/api/lidoWriteApi.d.ts

@@ -9,6 +9,7 @@
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
+import { AbandonDashboardRequest } from '../model/abandonDashboardRequest';
 import { ApproveStETH } from '../model/approveStETH';
 import { ApproveWstETH } from '../model/approveWstETH';
 import { BurnShares } from '../model/burnShares';
@@ -63,6 +64,35 @@ export declare class LidoWriteApi {
     setApiKey(key: LidoWriteApiApiKeys, value: string): void;
     set accessToken(accessToken: string | (() => string));
     addInterceptor(interceptor: Interceptor): void;
+    /**
+     * Returns a partial transaction to call Dashboard.abandonDashboard(newOwner). Only allowed when the vault is fully disconnected from the vault hub (after disconnect has completed). Step 3 of the stVault disconnect guide (with Dashboard).
+     * @summary Abandon dashboard and transfer vault ownership (disconnect Step 3)
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param abandonDashboardRequest
+     * @param simulateAddress Optional Ethereum address to simulate the transaction from.
+     */
+    abandonDashboard(contractsId: string, abandonDashboardRequest: AbandonDashboardRequest, simulateAddress?: string, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<{
+        body: PartialTransaction;
+        status: number;
+    }>;
+    /**
+     * Returns a partial transaction to call StakingVault.acceptOwnership(). Only allowed when the vault is fully disconnected from the vault hub. Step 4 of the stVault disconnect guide (with Dashboard), or Step 3 without Dashboard.
+     * @summary Accept staking vault ownership (disconnect Step 4)
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param simulateAddress Optional Ethereum address to simulate the transaction from.
+     */
+    acceptStakingVaultOwnership(contractsId: string, simulateAddress?: string, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<{
+        body: PartialTransaction;
+        status: number;
+    }>;
     /**
      *
      * @summary Encode approval to burn stETH
@@ -174,6 +204,20 @@ export declare class LidoWriteApi {
         body: PartialTransaction;
         status: number;
     }>;
+    /**
+     * Returns a partial transaction to connect the vault to the vault hub (payable with 1 ETH). Only allowed when the vault is not already connected; returns 400 if already connected.
+     * @summary Connect to vault hub
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param simulateAddress Optional Ethereum address to simulate the transaction from.
+     */
+    connectToVaultHub(contractsId: string, simulateAddress?: string, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<{
+        body: PartialTransaction;
+        status: number;
+    }>;
     /**
      *
      * @summary Create EIP-7251 consolidation requests for validators
@@ -385,7 +429,7 @@ export declare class LidoWriteApi {
         status: number;
     }>;
     /**
-     *
+     * Returns a partial transaction to trigger EIP-7002 validator withdrawals. When the vault is connected, uses Dashboard. When the vault is disconnected (e.g. after the disconnect wizard), uses StakingVault.triggerValidatorWithdrawals.
      * @summary Trigger validator withdrawals
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param triggerValidatorWithdrawals
@@ -440,7 +484,21 @@ export declare class LidoWriteApi {
         status: number;
     }>;
     /**
-     *
+     * Returns a partial transaction to voluntarily disconnect the vault from the vault hub. This is the only write operation allowed when the vault is already disconnected.
+     * @summary Voluntary disconnect from vault hub
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param simulateAddress Optional Ethereum address to simulate the transaction from.
+     */
+    voluntaryDisconnectFromVaultHub(contractsId: string, simulateAddress?: string, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<{
+        body: PartialTransaction;
+        status: number;
+    }>;
+    /**
+     * Returns a partial transaction to withdraw ETH. When the vault is connected, uses Dashboard.withdraw. When the vault is disconnected (e.g. after the disconnect wizard), uses StakingVault.withdraw(recipient, amount).
      * @summary Withdraw from vault
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param withdrawFromVault

package/dist/api/lidoWriteApi.js

@@ -75,6 +75,154 @@ class LidoWriteApi {
     addInterceptor(interceptor) {
         this.interceptors.push(interceptor);
     }
+    /**
+     * Returns a partial transaction to call Dashboard.abandonDashboard(newOwner). Only allowed when the vault is fully disconnected from the vault hub (after disconnect has completed). Step 3 of the stVault disconnect guide (with Dashboard).
+     * @summary Abandon dashboard and transfer vault ownership (disconnect Step 3)
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param abandonDashboardRequest
+     * @param simulateAddress Optional Ethereum address to simulate the transaction from.
+     */
+    async abandonDashboard(contractsId, abandonDashboardRequest, simulateAddress, options = { headers: {} }) {
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/abandon-dashboard'
+            .replace('{' + 'contractsId' + '}', encodeURIComponent(String(contractsId)));
+        let localVarQueryParameters = {};
+        let localVarHeaderParams = Object.assign({}, this._defaultHeaders);
+        const produces = ['application/json'];
+        if (produces.indexOf('application/json') >= 0) {
+            localVarHeaderParams.Accept = 'application/json';
+        }
+        else {
+            localVarHeaderParams.Accept = produces.join(',');
+        }
+        let localVarFormParams = {};
+        // Verify required parameter 'contractsId' is not null or undefined
+        if (contractsId === null || contractsId === undefined) {
+            throw new Error('Required parameter "contractsId" was null or undefined when calling abandonDashboard.');
+        }
+        // Verify required parameter 'abandonDashboardRequest' is not null or undefined
+        if (abandonDashboardRequest === null || abandonDashboardRequest === undefined) {
+            throw new Error('Required parameter "abandonDashboardRequest" was null or undefined when calling abandonDashboard.');
+        }
+        if (simulateAddress !== undefined) {
+            localVarQueryParameters['simulateAddress'] = models_1.ObjectSerializer.serialize(simulateAddress, "string");
+        }
+        Object.assign(localVarHeaderParams, options.headers);
+        let localVarUseFormData = false;
+        let localVarRequestOptions = {
+            method: 'POST',
+            qs: localVarQueryParameters,
+            headers: localVarHeaderParams,
+            uri: localVarPath,
+            useQuerystring: this._useQuerystring,
+            json: true,
+            body: models_1.ObjectSerializer.serialize(abandonDashboardRequest, "AbandonDashboardRequest")
+        };
+        let authenticationPromise = Promise.resolve();
+        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
+        let interceptorPromise = authenticationPromise;
+        for (const interceptor of this.interceptors) {
+            interceptorPromise = interceptorPromise.then(() => interceptor(localVarRequestOptions));
+        }
+        return interceptorPromise.then(() => {
+            if (Object.keys(localVarFormParams).length) {
+                if (localVarUseFormData) {
+                    localVarRequestOptions.formData = localVarFormParams;
+                }
+                else {
+                    localVarRequestOptions.form = localVarFormParams;
+                }
+            }
+            return new Promise((resolve, reject) => {
+                (0, request_1.default)(localVarRequestOptions, (error, response, body) => {
+                    if (error) {
+                        console.error('API call error:', error);
+                        reject(error);
+                    }
+                    else {
+                        if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
+                            body = models_1.ObjectSerializer.deserialize(body, "PartialTransaction");
+                            resolve({ body: body, status: response.statusCode });
+                        }
+                        else {
+                            console.error('API response error:', response.statusCode);
+                            resolve({ body: body, status: response.statusCode });
+                        }
+                    }
+                });
+            });
+        });
+    }
+    /**
+     * Returns a partial transaction to call StakingVault.acceptOwnership(). Only allowed when the vault is fully disconnected from the vault hub. Step 4 of the stVault disconnect guide (with Dashboard), or Step 3 without Dashboard.
+     * @summary Accept staking vault ownership (disconnect Step 4)
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param simulateAddress Optional Ethereum address to simulate the transaction from.
+     */
+    async acceptStakingVaultOwnership(contractsId, simulateAddress, options = { headers: {} }) {
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/accept-staking-vault-ownership'
+            .replace('{' + 'contractsId' + '}', encodeURIComponent(String(contractsId)));
+        let localVarQueryParameters = {};
+        let localVarHeaderParams = Object.assign({}, this._defaultHeaders);
+        const produces = ['application/json'];
+        if (produces.indexOf('application/json') >= 0) {
+            localVarHeaderParams.Accept = 'application/json';
+        }
+        else {
+            localVarHeaderParams.Accept = produces.join(',');
+        }
+        let localVarFormParams = {};
+        // Verify required parameter 'contractsId' is not null or undefined
+        if (contractsId === null || contractsId === undefined) {
+            throw new Error('Required parameter "contractsId" was null or undefined when calling acceptStakingVaultOwnership.');
+        }
+        if (simulateAddress !== undefined) {
+            localVarQueryParameters['simulateAddress'] = models_1.ObjectSerializer.serialize(simulateAddress, "string");
+        }
+        Object.assign(localVarHeaderParams, options.headers);
+        let localVarUseFormData = false;
+        let localVarRequestOptions = {
+            method: 'POST',
+            qs: localVarQueryParameters,
+            headers: localVarHeaderParams,
+            uri: localVarPath,
+            useQuerystring: this._useQuerystring,
+            json: true,
+        };
+        let authenticationPromise = Promise.resolve();
+        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
+        let interceptorPromise = authenticationPromise;
+        for (const interceptor of this.interceptors) {
+            interceptorPromise = interceptorPromise.then(() => interceptor(localVarRequestOptions));
+        }
+        return interceptorPromise.then(() => {
+            if (Object.keys(localVarFormParams).length) {
+                if (localVarUseFormData) {
+                    localVarRequestOptions.formData = localVarFormParams;
+                }
+                else {
+                    localVarRequestOptions.form = localVarFormParams;
+                }
+            }
+            return new Promise((resolve, reject) => {
+                (0, request_1.default)(localVarRequestOptions, (error, response, body) => {
+                    if (error) {
+                        console.error('API call error:', error);
+                        reject(error);
+                    }
+                    else {
+                        if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
+                            body = models_1.ObjectSerializer.deserialize(body, "PartialTransaction");
+                            resolve({ body: body, status: response.statusCode });
+                        }
+                        else {
+                            console.error('API response error:', response.statusCode);
+                            resolve({ body: body, status: response.statusCode });
+                        }
+                    }
+                });
+            });
+        });
+    }
     /**
      *
      * @summary Encode approval to burn stETH
@@ -653,6 +801,77 @@ class LidoWriteApi {
             });
         });
     }
+    /**
+     * Returns a partial transaction to connect the vault to the vault hub (payable with 1 ETH). Only allowed when the vault is not already connected; returns 400 if already connected.
+     * @summary Connect to vault hub
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param simulateAddress Optional Ethereum address to simulate the transaction from.
+     */
+    async connectToVaultHub(contractsId, simulateAddress, options = { headers: {} }) {
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/connect-to-vault-hub'
+            .replace('{' + 'contractsId' + '}', encodeURIComponent(String(contractsId)));
+        let localVarQueryParameters = {};
+        let localVarHeaderParams = Object.assign({}, this._defaultHeaders);
+        const produces = ['application/json'];
+        if (produces.indexOf('application/json') >= 0) {
+            localVarHeaderParams.Accept = 'application/json';
+        }
+        else {
+            localVarHeaderParams.Accept = produces.join(',');
+        }
+        let localVarFormParams = {};
+        // Verify required parameter 'contractsId' is not null or undefined
+        if (contractsId === null || contractsId === undefined) {
+            throw new Error('Required parameter "contractsId" was null or undefined when calling connectToVaultHub.');
+        }
+        if (simulateAddress !== undefined) {
+            localVarQueryParameters['simulateAddress'] = models_1.ObjectSerializer.serialize(simulateAddress, "string");
+        }
+        Object.assign(localVarHeaderParams, options.headers);
+        let localVarUseFormData = false;
+        let localVarRequestOptions = {
+            method: 'POST',
+            qs: localVarQueryParameters,
+            headers: localVarHeaderParams,
+            uri: localVarPath,
+            useQuerystring: this._useQuerystring,
+            json: true,
+        };
+        let authenticationPromise = Promise.resolve();
+        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
+        let interceptorPromise = authenticationPromise;
+        for (const interceptor of this.interceptors) {
+            interceptorPromise = interceptorPromise.then(() => interceptor(localVarRequestOptions));
+        }
+        return interceptorPromise.then(() => {
+            if (Object.keys(localVarFormParams).length) {
+                if (localVarUseFormData) {
+                    localVarRequestOptions.formData = localVarFormParams;
+                }
+                else {
+                    localVarRequestOptions.form = localVarFormParams;
+                }
+            }
+            return new Promise((resolve, reject) => {
+                (0, request_1.default)(localVarRequestOptions, (error, response, body) => {
+                    if (error) {
+                        console.error('API call error:', error);
+                        reject(error);
+                    }
+                    else {
+                        if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
+                            body = models_1.ObjectSerializer.deserialize(body, "PartialTransaction");
+                            resolve({ body: body, status: response.statusCode });
+                        }
+                        else {
+                            console.error('API response error:', response.statusCode);
+                            resolve({ body: body, status: response.statusCode });
+                        }
+                    }
+                });
+            });
+        });
+    }
     /**
      *
      * @summary Create EIP-7251 consolidation requests for validators
@@ -1743,7 +1962,7 @@ class LidoWriteApi {
         });
     }
     /**
-     *
+     * Returns a partial transaction to trigger EIP-7002 validator withdrawals. When the vault is connected, uses Dashboard. When the vault is disconnected (e.g. after the disconnect wizard), uses StakingVault.triggerValidatorWithdrawals.
      * @summary Trigger validator withdrawals
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param triggerValidatorWithdrawals
@@ -2029,7 +2248,78 @@ class LidoWriteApi {
         });
     }
     /**
-     *
+     * Returns a partial transaction to voluntarily disconnect the vault from the vault hub. This is the only write operation allowed when the vault is already disconnected.
+     * @summary Voluntary disconnect from vault hub
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param simulateAddress Optional Ethereum address to simulate the transaction from.
+     */
+    async voluntaryDisconnectFromVaultHub(contractsId, simulateAddress, options = { headers: {} }) {
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/voluntary-disconnect'
+            .replace('{' + 'contractsId' + '}', encodeURIComponent(String(contractsId)));
+        let localVarQueryParameters = {};
+        let localVarHeaderParams = Object.assign({}, this._defaultHeaders);
+        const produces = ['application/json'];
+        if (produces.indexOf('application/json') >= 0) {
+            localVarHeaderParams.Accept = 'application/json';
+        }
+        else {
+            localVarHeaderParams.Accept = produces.join(',');
+        }
+        let localVarFormParams = {};
+        // Verify required parameter 'contractsId' is not null or undefined
+        if (contractsId === null || contractsId === undefined) {
+            throw new Error('Required parameter "contractsId" was null or undefined when calling voluntaryDisconnectFromVaultHub.');
+        }
+        if (simulateAddress !== undefined) {
+            localVarQueryParameters['simulateAddress'] = models_1.ObjectSerializer.serialize(simulateAddress, "string");
+        }
+        Object.assign(localVarHeaderParams, options.headers);
+        let localVarUseFormData = false;
+        let localVarRequestOptions = {
+            method: 'POST',
+            qs: localVarQueryParameters,
+            headers: localVarHeaderParams,
+            uri: localVarPath,
+            useQuerystring: this._useQuerystring,
+            json: true,
+        };
+        let authenticationPromise = Promise.resolve();
+        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
+        let interceptorPromise = authenticationPromise;
+        for (const interceptor of this.interceptors) {
+            interceptorPromise = interceptorPromise.then(() => interceptor(localVarRequestOptions));
+        }
+        return interceptorPromise.then(() => {
+            if (Object.keys(localVarFormParams).length) {
+                if (localVarUseFormData) {
+                    localVarRequestOptions.formData = localVarFormParams;
+                }
+                else {
+                    localVarRequestOptions.form = localVarFormParams;
+                }
+            }
+            return new Promise((resolve, reject) => {
+                (0, request_1.default)(localVarRequestOptions, (error, response, body) => {
+                    if (error) {
+                        console.error('API call error:', error);
+                        reject(error);
+                    }
+                    else {
+                        if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
+                            body = models_1.ObjectSerializer.deserialize(body, "PartialTransaction");
+                            resolve({ body: body, status: response.statusCode });
+                        }
+                        else {
+                            console.error('API response error:', response.statusCode);
+                            resolve({ body: body, status: response.statusCode });
+                        }
+                    }
+                });
+            });
+        });
+    }
+    /**
+     * Returns a partial transaction to withdraw ETH. When the vault is connected, uses Dashboard.withdraw. When the vault is disconnected (e.g. after the disconnect wizard), uses StakingVault.withdraw(recipient, amount).
      * @summary Withdraw from vault
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param withdrawFromVault

package/dist/api/validatorsApi.d.ts

@@ -9,7 +9,6 @@
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
-import { GetWithdrawalsResponse } from '../model/getWithdrawalsResponse';
 import { PartialTransaction } from '../model/partialTransaction';
 import { ValidatorInfo } from '../model/validatorInfo';
 import { Authentication, Interceptor } from '../model/models';
@@ -17,14 +16,6 @@ import { HttpBearerAuth, ApiKeyAuth } from '../model/models';
 export declare enum ValidatorsApiApiKeys {
     ApiKeyAuth = 0
 }
-export interface ValidatorsApiParams {
-    startDate?: Date;
-    endDate?: Date;
-    page?: number;
-    limit?: number;
-    validatorIndices?: string;
-    withdrawalType?: 'full' | 'partial';
-}
 export declare class ValidatorsApi {
     protected _basePath: string;
     protected _defaultHeaders: any;
@@ -45,24 +36,6 @@ export declare class ValidatorsApi {
     setApiKey(key: ValidatorsApiApiKeys, value: string): void;
     set accessToken(accessToken: string | (() => string));
     addInterceptor(interceptor: Interceptor): void;
-    /**
-     * Retrieves a paginated list of validator withdrawals. The endpoint supports filtering by start and end date, page number, and limit. Additionally, it allows filtering by validator indices.
-     * @summary Get a list of validator withdrawals
-     * @param startDate Start date for filtering withdrawal statistics
-     * @param endDate End date for filtering withdrawal statistics
-     * @param page Withdrawal list page number
-     * @param limit Number of withdrawals to return per page
-     * @param validatorIndices Comma-separated list of validator indices to filter withdrawals (e.g., \"123,456,789\")
-     * @param withdrawalType
-     */
-    getValidatorWithdrawals(params?: ValidatorsApiParams, options?: {
-        headers: {
-            [name: string]: string;
-        };
-    }): Promise<{
-        body: GetWithdrawalsResponse;
-        status: number;
-    }>;
     /**
      *
      * @summary Get a list of validators