@radix-effects/gateway 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (4) hide show
  1. package/README.md +86 -0
  2. package/dist/index.d.ts +461 -0
  3. package/dist/index.js +771 -0
  4. package/package.json +40 -0
package/README.md ADDED
@@ -0,0 +1,86 @@
1
+ # @radix-effects/gateway
2
+
3
+ Effect-based Gateway API client for the Radix Network. Works in both Node.js and browser environments.
4
+
5
+ ## Installation
6
+
7
+ ```bash
8
+ npm install @radix-effects/gateway effect
9
+ ```
10
+
11
+ ## Usage
12
+
13
+ This package provides Effect-based wrappers around the Radix Gateway API, with full support for both Node.js and browser runtimes. See the [Effect docs](https://effect.website) for more details.
14
+
15
+ ### Basic Setup
16
+
17
+ ```typescript
18
+ import { Effect } from 'effect';
19
+ import { GatewayApiClientService, getEntityDetails } from '@radix-effects/gateway';
20
+
21
+ const program = Effect.gen(function* () {
22
+ const entityDetails = yield* getEntityDetails({
23
+ address: 'account_rdx12example123456789abcdef123456789abcdef123456789abcdef'
24
+ });
25
+
26
+ return entityDetails;
27
+ });
28
+
29
+ const result = await Effect.runPromise(
30
+ program.pipe(
31
+ Effect.provide(GatewayApiClientService.Default)
32
+ )
33
+ );
34
+ ```
35
+
36
+ ## Configuration
37
+
38
+ ### Environment Variables (Node.js)
39
+
40
+ The Gateway client can be configured through environment variables:
41
+
42
+ - `NETWORK_ID` - Optional Network ID (default: 1 for mainnet)
43
+ - `GATEWAY_URL` - Optional Gateway API base URL
44
+ - `APPLICATION_NAME` - Optional Application identifier (default: '@')
45
+ - `GATEWAY_BASIC_AUTH` - Optional API key for authentication
46
+ - `GATEWAY_RETRY_ATTEMPTS` - Optional number of retry attempts (default: 5)
47
+
48
+ ### Browser Runtime Configuration
49
+
50
+ In browser environments, use ConfigProvider to set configuration:
51
+
52
+ ```typescript
53
+ import { Effect, ConfigProvider, Layer } from 'effect';
54
+ import { GatewayApiClientService } from '@radix-effects/gateway';
55
+
56
+ // Create a configuration provider with your settings
57
+ const browserConfig = ConfigProvider.fromMap(new Map([
58
+ ['NETWORK_ID', '2'], // Testnet
59
+ ['GATEWAY_URL', 'https://testnet.radixdlt.com'],
60
+ ['APPLICATION_NAME', 'my-dapp'],
61
+ ['GATEWAY_RETRY_ATTEMPTS', '3']
62
+ ]));
63
+
64
+ // Create a layer with the config provider
65
+ const BrowserGatewayLayer = Layer.provide(
66
+ GatewayApiClientService.Default,
67
+ Layer.setConfigProvider(browserConfig)
68
+ );
69
+
70
+ // Use in your application
71
+ const program = Effect.gen(function* () {
72
+ const details = yield* getEntityDetails({
73
+ address: 'account_rdx1...'
74
+ });
75
+ return details;
76
+ });
77
+
78
+ // Run with browser configuration
79
+ const result = await Effect.runPromise(
80
+ program.pipe(Effect.provide(BrowserGatewayLayer))
81
+ );
82
+ ```
83
+
84
+ ## License
85
+
86
+ MIT
package/dist/index.d.ts ADDED
@@ -0,0 +1,461 @@
1
+ import { Effect } from "effect";
2
+ import * as _radixdlt_babylon_gateway_api_sdk6 from "@radixdlt/babylon-gateway-api-sdk";
3
+ import { AccountLockerNotFoundError as AccountLockerNotFoundError$1, EntityFungiblesPageRequest, EntityNotFoundError as EntityNotFoundError$1, ErrorResponse as ErrorResponse$1, GatewayApiClient as GatewayApiClient$1, InternalServerError as InternalServerError$1, InvalidEntityError as InvalidEntityError$1, InvalidRequestError as InvalidRequestError$1, InvalidTransactionError as InvalidTransactionError$1, NotSyncedUpError as NotSyncedUpError$1, ResourceHoldersCollectionItem, ResponseError as ResponseError$1, StateEntityDetailsOperationRequest, StateEntityDetailsVaultResponseItem, StateKeyValueStoreDataRequest, StateKeyValueStoreKeysRequest, TransactionNotFoundError as TransactionNotFoundError$1 } from "@radixdlt/babylon-gateway-api-sdk";
4
+ import { z } from "zod";
5
+ import * as effect_ConfigError11 from "effect/ConfigError";
6
+ import * as effect_Layer0 from "effect/Layer";
7
+ import * as effect_Types0 from "effect/Types";
8
+ import * as effect_Cause0 from "effect/Cause";
9
+ import { ParsedType, StructDefinition, StructSchema } from "sbor-ez-mode";
10
+
11
+ //#region src/gatewayApiClient.d.ts
12
+ declare const AccountLockerNotFoundError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
13
+ readonly _tag: "AccountLockerNotFoundError";
14
+ } & Readonly<A>;
15
+ declare class AccountLockerNotFoundError extends AccountLockerNotFoundError_base<AccountLockerNotFoundError$1 & {
16
+ code?: number;
17
+ message?: string;
18
+ }> {}
19
+ declare const InternalServerError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
20
+ readonly _tag: "InternalServerError";
21
+ } & Readonly<A>;
22
+ declare class InternalServerError extends InternalServerError_base<InternalServerError$1 & {
23
+ code?: number;
24
+ message?: string;
25
+ }> {}
26
+ declare const InvalidRequestError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
27
+ readonly _tag: "InvalidRequestError";
28
+ } & Readonly<A>;
29
+ declare class InvalidRequestError extends InvalidRequestError_base<InvalidRequestError$1 & {
30
+ code?: number;
31
+ message?: string;
32
+ }> {}
33
+ declare const InvalidEntityError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
34
+ readonly _tag: "InvalidEntityError";
35
+ } & Readonly<A>;
36
+ declare class InvalidEntityError extends InvalidEntityError_base<InvalidEntityError$1 & {
37
+ code?: number;
38
+ message?: string;
39
+ }> {}
40
+ declare const EntityNotFoundError_base$1: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
41
+ readonly _tag: "EntityNotFoundError";
42
+ } & Readonly<A>;
43
+ declare class EntityNotFoundError extends EntityNotFoundError_base$1<EntityNotFoundError$1 & {
44
+ code?: number;
45
+ message?: string;
46
+ }> {}
47
+ declare const NotSyncedUpError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
48
+ readonly _tag: "NotSyncedUpError";
49
+ } & Readonly<A>;
50
+ declare class NotSyncedUpError extends NotSyncedUpError_base<NotSyncedUpError$1 & {
51
+ code?: number;
52
+ message?: string;
53
+ }> {}
54
+ declare const TransactionNotFoundError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
55
+ readonly _tag: "TransactionNotFoundError";
56
+ } & Readonly<A>;
57
+ declare class TransactionNotFoundError extends TransactionNotFoundError_base<TransactionNotFoundError$1 & {
58
+ code?: number;
59
+ message?: string;
60
+ }> {}
61
+ declare const InvalidTransactionError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
62
+ readonly _tag: "InvalidTransactionError";
63
+ } & Readonly<A>;
64
+ declare class InvalidTransactionError extends InvalidTransactionError_base<InvalidTransactionError$1 & {
65
+ code?: number;
66
+ message?: string;
67
+ }> {}
68
+ declare const ResponseError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
69
+ readonly _tag: "ResponseError";
70
+ } & Readonly<A>;
71
+ declare class ResponseError extends ResponseError_base<ResponseError$1> {}
72
+ declare const ErrorResponse_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
73
+ readonly _tag: "ErrorResponse";
74
+ } & Readonly<A>;
75
+ declare class ErrorResponse extends ErrorResponse_base<ErrorResponse$1> {}
76
+ declare const RateLimitExceededError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
77
+ readonly _tag: "RateLimitExceededError";
78
+ } & Readonly<A>;
79
+ declare class RateLimitExceededError extends RateLimitExceededError_base<{
80
+ code: number;
81
+ message: string;
82
+ retryAfter: number;
83
+ }> {}
84
+ declare const UnknownGatewayError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
85
+ readonly _tag: "UnknownGatewayError";
86
+ } & Readonly<A>;
87
+ declare class UnknownGatewayError extends UnknownGatewayError_base<{
88
+ error: unknown;
89
+ }> {}
90
+ declare const GatewayApiClient_base: Effect.Service.Class<GatewayApiClient, "GatewayApiClient", {
91
+ readonly effect: Effect.Effect<{
92
+ state: {
93
+ getEntityDetailsVaultAggregated: (addresses: string[], options?: _radixdlt_babylon_gateway_api_sdk6.StateEntityDetailsOptions | undefined, ledgerState?: _radixdlt_babylon_gateway_api_sdk6.LedgerStateSelector | undefined) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk6.StateEntityDetailsVaultResponseItem[], AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>;
94
+ getValidators: (cursor?: string | undefined) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk6.ValidatorCollection, AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>;
95
+ innerClient: {
96
+ stateEntityDetails: (requestParameters: _radixdlt_babylon_gateway_api_sdk6.StateEntityDetailsOperationRequest, initOverrides?: RequestInit | _radixdlt_babylon_gateway_api_sdk6.InitOverrideFunction | undefined) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk6.StateEntityDetailsResponse, AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>;
97
+ entityFungiblesPage: (requestParameters: _radixdlt_babylon_gateway_api_sdk6.EntityFungiblesPageRequest, initOverrides?: RequestInit | _radixdlt_babylon_gateway_api_sdk6.InitOverrideFunction | undefined) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk6.StateEntityFungiblesPageResponse, AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>;
98
+ entityNonFungiblesPage: (requestParameters: _radixdlt_babylon_gateway_api_sdk6.EntityNonFungiblesPageRequest, initOverrides?: RequestInit | _radixdlt_babylon_gateway_api_sdk6.InitOverrideFunction | undefined) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk6.StateEntityNonFungiblesPageResponse, AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>;
99
+ entityNonFungibleIdsPage: (requestParameters: _radixdlt_babylon_gateway_api_sdk6.EntityNonFungibleIdsPageRequest, initOverrides?: RequestInit | _radixdlt_babylon_gateway_api_sdk6.InitOverrideFunction | undefined) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk6.StateEntityNonFungibleIdsPageResponse, AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>;
100
+ entityNonFungibleResourceVaultPage: (requestParameters: _radixdlt_babylon_gateway_api_sdk6.EntityNonFungibleResourceVaultPageRequest, initOverrides?: RequestInit | _radixdlt_babylon_gateway_api_sdk6.InitOverrideFunction | undefined) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk6.StateEntityNonFungibleResourceVaultsPageResponse, AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>;
101
+ keyValueStoreKeys: (requestParameters: _radixdlt_babylon_gateway_api_sdk6.KeyValueStoreKeysRequest, initOverrides?: RequestInit | _radixdlt_babylon_gateway_api_sdk6.InitOverrideFunction | undefined) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk6.StateKeyValueStoreKeysResponse, AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>;
102
+ keyValueStoreData: (requestParameters: _radixdlt_babylon_gateway_api_sdk6.KeyValueStoreDataRequest, initOverrides?: RequestInit | _radixdlt_babylon_gateway_api_sdk6.InitOverrideFunction | undefined) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk6.StateKeyValueStoreDataResponse, AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>;
103
+ nonFungibleData: (requestParameters: _radixdlt_babylon_gateway_api_sdk6.NonFungibleDataRequest, initOverrides?: RequestInit | _radixdlt_babylon_gateway_api_sdk6.InitOverrideFunction | undefined) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk6.StateNonFungibleDataResponse, AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>;
104
+ nonFungibleLocation: (requestParameters: _radixdlt_babylon_gateway_api_sdk6.NonFungibleLocationRequest, initOverrides?: RequestInit | _radixdlt_babylon_gateway_api_sdk6.InitOverrideFunction | undefined) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk6.StateNonFungibleLocationResponse, AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>;
105
+ nonFungibleIds: (requestParameters: _radixdlt_babylon_gateway_api_sdk6.NonFungibleIdsRequest, initOverrides?: RequestInit | _radixdlt_babylon_gateway_api_sdk6.InitOverrideFunction | undefined) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk6.StateNonFungibleIdsResponse, AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>;
106
+ };
107
+ };
108
+ stream: {
109
+ innerClient: {
110
+ streamTransactions: (requestParameters: _radixdlt_babylon_gateway_api_sdk6.StreamTransactionsOperationRequest, initOverrides?: RequestInit | _radixdlt_babylon_gateway_api_sdk6.InitOverrideFunction | undefined) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk6.StreamTransactionsResponse, AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>;
111
+ };
112
+ };
113
+ transaction: {
114
+ getCommittedDetails: (transactionIntentHash: string, options?: {
115
+ rawHex: boolean;
116
+ receiptEvents: boolean;
117
+ receiptFeeSource: boolean;
118
+ receiptFeeSummary: boolean;
119
+ receiptFeeDestination: boolean;
120
+ receiptCostingParameters: boolean;
121
+ receiptStateChanges: boolean;
122
+ affectedGlobalEntities: boolean;
123
+ balanceChanges: boolean;
124
+ receiptOutput: boolean;
125
+ manifestInstructions: boolean;
126
+ } | undefined) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk6.TransactionCommittedDetailsResponse, AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>;
127
+ innerClient: {
128
+ transactionSubmit: (requestParameters: _radixdlt_babylon_gateway_api_sdk6.TransactionSubmitOperationRequest, initOverrides?: RequestInit | _radixdlt_babylon_gateway_api_sdk6.InitOverrideFunction | undefined) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk6.TransactionSubmitResponse, AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>;
129
+ transactionStatus: (requestParameters: _radixdlt_babylon_gateway_api_sdk6.TransactionStatusOperationRequest, initOverrides?: RequestInit | _radixdlt_babylon_gateway_api_sdk6.InitOverrideFunction | undefined) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk6.TransactionStatusResponse, AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>;
130
+ };
131
+ };
132
+ status: {
133
+ getCurrent: () => Effect.Effect<_radixdlt_babylon_gateway_api_sdk6.GatewayStatusResponse, AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>;
134
+ innerClient: {
135
+ gatewayStatus: (initOverrides?: RequestInit | _radixdlt_babylon_gateway_api_sdk6.InitOverrideFunction | undefined) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk6.GatewayStatusResponse, AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>;
136
+ };
137
+ };
138
+ extensions: {
139
+ getResourceHolders: (resourceAddress: string, cursor?: string | undefined) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk6.ResourceHoldersResponse, AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>;
140
+ };
141
+ rawClient: GatewayApiClient$1;
142
+ }, effect_ConfigError11.ConfigError, never>;
143
+ }>;
144
+ declare class GatewayApiClient extends GatewayApiClient_base {}
145
+ //#endregion
146
+ //#region src/schemas.d.ts
147
+ declare const StateVersionSchema: z.ZodObject<{
148
+ state_version: z.ZodNumber;
149
+ }, "strip", z.ZodTypeAny, {
150
+ state_version: number;
151
+ }, {
152
+ state_version: number;
153
+ }>;
154
+ type StateVersion = z.infer<typeof StateVersionSchema>;
155
+ declare const TimestampSchema: z.ZodObject<{
156
+ timestamp: z.ZodDate;
157
+ }, "strip", z.ZodTypeAny, {
158
+ timestamp: Date;
159
+ }, {
160
+ timestamp: Date;
161
+ }>;
162
+ declare const AtLedgerStateSchema: z.ZodUnion<[z.ZodObject<{
163
+ state_version: z.ZodNumber;
164
+ }, "strip", z.ZodTypeAny, {
165
+ state_version: number;
166
+ }, {
167
+ state_version: number;
168
+ }>, z.ZodObject<{
169
+ timestamp: z.ZodDate;
170
+ }, "strip", z.ZodTypeAny, {
171
+ timestamp: Date;
172
+ }, {
173
+ timestamp: Date;
174
+ }>]>;
175
+ type AtLedgerState = z.infer<typeof AtLedgerStateSchema>;
176
+ declare class InvalidStateInputError {
177
+ readonly error: z.ZodError<AtLedgerState>;
178
+ readonly _tag = "InvalidStateInputError";
179
+ constructor(error: z.ZodError<AtLedgerState>);
180
+ }
181
+ declare const validateAtLedgerStateInput: (input: unknown) => Effect.Effect<AtLedgerState, InvalidStateInputError>;
182
+ //#endregion
183
+ //#region src/state/entityFungiblesPage.d.ts
184
+ type EntityFungiblesPageInput = Omit<EntityFungiblesPageRequest['stateEntityFungiblesPageRequest'], 'at_ledger_state'> & {
185
+ at_ledger_state: AtLedgerState;
186
+ };
187
+ declare const EntityFungiblesPage_base: Effect.Service.Class<EntityFungiblesPage, "EntityFungiblesPage", {
188
+ readonly dependencies: readonly [effect_Layer0.Layer<GatewayApiClient, effect_ConfigError11.ConfigError, never>];
189
+ readonly effect: Effect.Effect<(this: unknown, input: EntityFungiblesPageInput) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk6.FungibleResourcesCollectionItem[], AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>, effect_ConfigError11.ConfigError, GatewayApiClient>;
190
+ }>;
191
+ declare class EntityFungiblesPage extends EntityFungiblesPage_base {}
192
+ //#endregion
193
+ //#region src/state/nonFungibleData.d.ts
194
+ declare const NonFungibleData_base: Effect.Service.Class<NonFungibleData, "NonFungibleData", {
195
+ readonly dependencies: readonly [effect_Layer0.Layer<GatewayApiClient, effect_ConfigError11.ConfigError, never>];
196
+ readonly effect: Effect.Effect<(this: unknown, input: Omit<_radixdlt_babylon_gateway_api_sdk6.StateNonFungibleDataRequest, "at_ledger_state"> & {
197
+ at_ledger_state: AtLedgerState;
198
+ }) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk6.StateNonFungibleDetailsResponseItem[], AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>, effect_ConfigError11.ConfigError, GatewayApiClient>;
199
+ }>;
200
+ declare class NonFungibleData extends NonFungibleData_base {}
201
+ //#endregion
202
+ //#region src/state/entityNonFungiblesPage.d.ts
203
+ declare const EntityNonFungiblesPage_base: Effect.Service.Class<EntityNonFungiblesPage, "EntityNonFungiblesPage", {
204
+ readonly dependencies: readonly [effect_Layer0.Layer<GatewayApiClient, effect_ConfigError11.ConfigError, never>];
205
+ readonly effect: Effect.Effect<(this: unknown, input: Omit<_radixdlt_babylon_gateway_api_sdk6.StateEntityNonFungiblesPageRequest, "at_ledger_state"> & {
206
+ at_ledger_state: AtLedgerState;
207
+ }) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk6.StateEntityNonFungiblesPageResponse, AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>, effect_ConfigError11.ConfigError, GatewayApiClient>;
208
+ }>;
209
+ declare class EntityNonFungiblesPage extends EntityNonFungiblesPage_base {}
210
+ //#endregion
211
+ //#region src/state/getValidators.d.ts
212
+ declare const ValidatorSchema: z.ZodObject<{
213
+ address: z.ZodString;
214
+ name: z.ZodString;
215
+ lsuResourceAddress: z.ZodString;
216
+ claimNftResourceAddress: z.ZodString;
217
+ }, "strip", z.ZodTypeAny, {
218
+ name: string;
219
+ address: string;
220
+ lsuResourceAddress: string;
221
+ claimNftResourceAddress: string;
222
+ }, {
223
+ name: string;
224
+ address: string;
225
+ lsuResourceAddress: string;
226
+ claimNftResourceAddress: string;
227
+ }>;
228
+ type Validator = z.infer<typeof ValidatorSchema>;
229
+ declare const GetValidators_base: Effect.Service.Class<GetValidators, "GetValidators", {
230
+ readonly dependencies: readonly [effect_Layer0.Layer<GatewayApiClient, effect_ConfigError11.ConfigError, never>];
231
+ readonly effect: Effect.Effect<(this: unknown) => Effect.Effect<{
232
+ address: string;
233
+ name: string;
234
+ lsuResourceAddress: string;
235
+ claimNftResourceAddress: string;
236
+ }[], AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>, never, GatewayApiClient>;
237
+ }>;
238
+ declare class GetValidators extends GetValidators_base {}
239
+ //#endregion
240
+ //#region src/state/getEntityDetailsVaultAggregated.d.ts
241
+ type GetEntityDetailsVaultAggregatedParameters = Parameters<(typeof GatewayApiClient)['Service']['state']['getEntityDetailsVaultAggregated']>;
242
+ type GetEntityDetailsInput = GetEntityDetailsVaultAggregatedParameters[0];
243
+ type GetEntityDetailsOptions = GetEntityDetailsVaultAggregatedParameters[1];
244
+ type GetEntityDetailsState = GetEntityDetailsVaultAggregatedParameters[2];
245
+ declare const GetEntityDetailsVaultAggregated_base: Effect.Service.Class<GetEntityDetailsVaultAggregated, "GetEntityDetailsVaultAggregated", {
246
+ readonly dependencies: readonly [effect_Layer0.Layer<GatewayApiClient, effect_ConfigError11.ConfigError, never>];
247
+ readonly effect: Effect.Effect<(this: unknown, input: string[], options: _radixdlt_babylon_gateway_api_sdk6.StateEntityDetailsOptions | undefined, at_ledger_state: {
248
+ state_version: number;
249
+ } | {
250
+ timestamp: Date;
251
+ }) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk6.StateEntityDetailsVaultResponseItem[], AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>, effect_ConfigError11.ConfigError, GatewayApiClient>;
252
+ }>;
253
+ declare class GetEntityDetailsVaultAggregated extends GetEntityDetailsVaultAggregated_base {}
254
+ //#endregion
255
+ //#region src/state/entityNonFungibleIdsPage.d.ts
256
+ type GetNonFungibleIdsInput = {
257
+ vaultAddress: string;
258
+ resourceAddress: string;
259
+ at_ledger_state: AtLedgerState;
260
+ address: string;
261
+ cursor?: string;
262
+ };
263
+ declare const EntityNonFungibleIdsPage_base: Effect.Service.Class<EntityNonFungibleIdsPage, "EntityNonFungibleIdsPage", {
264
+ readonly dependencies: readonly [effect_Layer0.Layer<GatewayApiClient, effect_ConfigError11.ConfigError, never>];
265
+ readonly effect: Effect.Effect<(this: unknown, input: GetNonFungibleIdsInput) => Effect.Effect<{
266
+ ids: string[];
267
+ address: string;
268
+ }, AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>, effect_ConfigError11.ConfigError, GatewayApiClient>;
269
+ }>;
270
+ declare class EntityNonFungibleIdsPage extends EntityNonFungibleIdsPage_base {}
271
+ //#endregion
272
+ //#region src/getNonFungibleLocation.d.ts
273
+ declare const GetNonFungibleLocationService_base: Effect.Service.Class<GetNonFungibleLocationService, "GetNonFungibleLocationService", {
274
+ readonly dependencies: readonly [effect_Layer0.Layer<GatewayApiClient, effect_ConfigError11.ConfigError, never>];
275
+ readonly effect: Effect.Effect<(this: unknown, input: {
276
+ resourceAddress: string;
277
+ nonFungibleIds: string[];
278
+ at_ledger_state: AtLedgerState;
279
+ }) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk6.StateNonFungibleLocationResponse[], AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>, effect_ConfigError11.ConfigError, GatewayApiClient>;
280
+ }>;
281
+ declare class GetNonFungibleLocationService extends GetNonFungibleLocationService_base {}
282
+ //#endregion
283
+ //#region src/getAddressByNonFungible.d.ts
284
+ declare const EntityNotFoundError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
285
+ readonly _tag: "EntityNotFoundError";
286
+ } & Readonly<A>;
287
+ declare class EntityNotFoundError$2 extends EntityNotFoundError_base<{
288
+ message: string;
289
+ }> {}
290
+ type GetAddressByNonFungibleServiceInput = {
291
+ resourceAddress: string;
292
+ nonFungibleId: string;
293
+ at_ledger_state: AtLedgerState;
294
+ };
295
+ declare const GetAddressByNonFungibleService_base: Effect.Service.Class<GetAddressByNonFungibleService, "GetAddressByNonFungibleService", {
296
+ readonly dependencies: readonly [effect_Layer0.Layer<GetNonFungibleLocationService, effect_ConfigError11.ConfigError, never>];
297
+ readonly effect: Effect.Effect<(this: unknown, input: GetAddressByNonFungibleServiceInput) => Effect.Effect<{
298
+ address: string;
299
+ resourceAddress: string;
300
+ nonFungibleId: string;
301
+ }, AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError | EntityNotFoundError$2, never>, never, GetNonFungibleLocationService>;
302
+ }>;
303
+ declare class GetAddressByNonFungibleService extends GetAddressByNonFungibleService_base {}
304
+ //#endregion
305
+ //#region src/getComponentState.d.ts
306
+ declare class InvalidComponentStateError {
307
+ readonly error: unknown;
308
+ readonly _tag = "InvalidComponentStateError";
309
+ constructor(error: unknown);
310
+ }
311
+ declare const GetComponentStateService_base: Effect.Service.Class<GetComponentStateService, "GetComponentStateService", {
312
+ readonly dependencies: readonly [effect_Layer0.Layer<GetEntityDetailsVaultAggregated, effect_ConfigError11.ConfigError, never>];
313
+ readonly effect: Effect.Effect<{
314
+ run: <T extends StructDefinition, R extends boolean>(this: unknown, input: {
315
+ addresses: string[];
316
+ at_ledger_state: AtLedgerState;
317
+ schema: StructSchema<T, R>;
318
+ options?: GetEntityDetailsOptions;
319
+ }) => Effect.Effect<{
320
+ address: string;
321
+ state: { [K in keyof T]: R extends true ? ParsedType<T[K]> | null : ParsedType<T[K]> };
322
+ details: StateEntityDetailsVaultResponseItem;
323
+ }[], AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError | InvalidComponentStateError, never>;
324
+ }, never, GetEntityDetailsVaultAggregated>;
325
+ }>;
326
+ declare class GetComponentStateService extends GetComponentStateService_base {}
327
+ //#endregion
328
+ //#region src/state/stateEntityDetails.d.ts
329
+ declare const StateEntityDetails_base: Effect.Service.Class<StateEntityDetails, "StateEntityDetails", {
330
+ readonly dependencies: readonly [effect_Layer0.Layer<GatewayApiClient, effect_ConfigError11.ConfigError, never>];
331
+ readonly effect: Effect.Effect<(this: unknown, input: _radixdlt_babylon_gateway_api_sdk6.StateEntityDetailsRequest) => Effect.Effect<{
332
+ ledger_state: _radixdlt_babylon_gateway_api_sdk6.LedgerState;
333
+ items: _radixdlt_babylon_gateway_api_sdk6.StateEntityDetailsResponseItem[];
334
+ }, AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>, effect_ConfigError11.ConfigError, GatewayApiClient>;
335
+ }>;
336
+ declare class StateEntityDetails extends StateEntityDetails_base {}
337
+ //#endregion
338
+ //#region src/getFungibleBalance.d.ts
339
+ type GetFungibleBalanceOutput = Effect.Effect.Success<Awaited<ReturnType<(typeof GetFungibleBalance)['Service']>>>;
340
+ type GetFungibleBalanceInput = Omit<StateEntityDetailsOperationRequest['stateEntityDetailsRequest'], 'at_ledger_state'> & {
341
+ at_ledger_state: StateVersion;
342
+ options?: StateEntityDetailsOperationRequest['stateEntityDetailsRequest']['opt_ins'];
343
+ };
344
+ declare const GetFungibleBalance_base: Effect.Service.Class<GetFungibleBalance, "GetFungibleBalance", {
345
+ readonly dependencies: readonly [effect_Layer0.Layer<EntityFungiblesPage, effect_ConfigError11.ConfigError, never>, effect_Layer0.Layer<StateEntityDetails, effect_ConfigError11.ConfigError, never>];
346
+ readonly effect: Effect.Effect<(this: unknown, input: GetFungibleBalanceInput) => Effect.Effect<{
347
+ address: string;
348
+ items: {
349
+ amount: BigNumber;
350
+ resource_address: string;
351
+ explicit_metadata?: _radixdlt_babylon_gateway_api_sdk6.EntityMetadataCollection;
352
+ last_updated_at_state_version: number;
353
+ }[];
354
+ }[], AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>, effect_ConfigError11.ConfigError, EntityFungiblesPage | StateEntityDetails>;
355
+ }>;
356
+ declare class GetFungibleBalance extends GetFungibleBalance_base {}
357
+ //#endregion
358
+ //#region src/keyValueStoreData.d.ts
359
+ declare const KeyValueStoreDataService_base: Effect.Service.Class<KeyValueStoreDataService, "KeyValueStoreDataService", {
360
+ readonly dependencies: readonly [effect_Layer0.Layer<GatewayApiClient, effect_ConfigError11.ConfigError, never>];
361
+ readonly effect: Effect.Effect<(this: unknown, input: Omit<StateKeyValueStoreDataRequest, "at_ledger_state"> & {
362
+ at_ledger_state: AtLedgerState;
363
+ }) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk6.StateKeyValueStoreDataResponse[], AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>, effect_ConfigError11.ConfigError, GatewayApiClient>;
364
+ }>;
365
+ declare class KeyValueStoreDataService extends KeyValueStoreDataService_base {}
366
+ //#endregion
367
+ //#region src/keyValueStoreKeys.d.ts
368
+ declare const KeyValueStoreKeysService_base: Effect.Service.Class<KeyValueStoreKeysService, "KeyValueStoreKeysService", {
369
+ readonly dependencies: readonly [effect_Layer0.Layer<GatewayApiClient, effect_ConfigError11.ConfigError, never>];
370
+ readonly effect: Effect.Effect<(this: unknown, input: Omit<StateKeyValueStoreKeysRequest, "at_ledger_state"> & {
371
+ at_ledger_state: AtLedgerState;
372
+ }) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk6.StateKeyValueStoreKeysResponse, AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>, effect_ConfigError11.ConfigError, GatewayApiClient>;
373
+ }>;
374
+ declare class KeyValueStoreKeysService extends KeyValueStoreKeysService_base {}
375
+ //#endregion
376
+ //#region src/getKeyValueStore.d.ts
377
+ declare const GetKeyValueStoreService_base: Effect.Service.Class<GetKeyValueStoreService, "GetKeyValueStoreService", {
378
+ readonly dependencies: readonly [effect_Layer0.Layer<KeyValueStoreKeysService, effect_ConfigError11.ConfigError, never>, effect_Layer0.Layer<KeyValueStoreDataService, effect_ConfigError11.ConfigError, never>];
379
+ readonly effect: Effect.Effect<(this: unknown, input: {
380
+ address: string;
381
+ at_ledger_state: AtLedgerState;
382
+ }) => Effect.Effect<{
383
+ key_value_store_address: string;
384
+ ledger_state: _radixdlt_babylon_gateway_api_sdk6.LedgerState;
385
+ entries: _radixdlt_babylon_gateway_api_sdk6.StateKeyValueStoreDataResponseItem[];
386
+ }, AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>, never, KeyValueStoreKeysService | KeyValueStoreDataService>;
387
+ }>;
388
+ declare class GetKeyValueStoreService extends GetKeyValueStoreService_base {}
389
+ //#endregion
390
+ //#region src/getLedgerState.d.ts
391
+ type GetLedgerStateInput = {
392
+ at_ledger_state: AtLedgerState;
393
+ };
394
+ declare const GetLedgerStateService_base: Effect.Service.Class<GetLedgerStateService, "GetLedgerStateService", {
395
+ readonly dependencies: readonly [effect_Layer0.Layer<GatewayApiClient, effect_ConfigError11.ConfigError, never>];
396
+ readonly effect: Effect.Effect<(this: unknown, input: GetLedgerStateInput) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk6.LedgerState, AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>, never, GatewayApiClient>;
397
+ }>;
398
+ declare class GetLedgerStateService extends GetLedgerStateService_base {}
399
+ //#endregion
400
+ //#region src/getNftResourceManagers.d.ts
401
+ type GetNftResourceManagersInput = {
402
+ addresses: string[];
403
+ at_ledger_state: AtLedgerState;
404
+ resourceAddresses?: string[];
405
+ options?: StateEntityDetailsOperationRequest['stateEntityDetailsRequest']['opt_ins'];
406
+ };
407
+ declare const GetNftResourceManagersService_base: Effect.Service.Class<GetNftResourceManagersService, "GetNftResourceManagersService", {
408
+ readonly dependencies: readonly [effect_Layer0.Layer<GatewayApiClient, effect_ConfigError11.ConfigError, never>, effect_Layer0.Layer<EntityNonFungiblesPage, effect_ConfigError11.ConfigError, never>, effect_Layer0.Layer<EntityNonFungibleIdsPage, effect_ConfigError11.ConfigError, never>];
409
+ readonly effect: Effect.Effect<(this: unknown, input: GetNftResourceManagersInput) => Effect.Effect<{
410
+ address: string;
411
+ items: {
412
+ resourceAddress: string;
413
+ nftIds: string[];
414
+ }[];
415
+ }[], AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>, effect_ConfigError11.ConfigError, EntityNonFungiblesPage | GatewayApiClient | EntityNonFungibleIdsPage>;
416
+ }>;
417
+ declare class GetNftResourceManagersService extends GetNftResourceManagersService_base {}
418
+ //#endregion
419
+ //#region src/getNonFungibleBalance.d.ts
420
+ declare class InvalidInputError {
421
+ readonly error: unknown;
422
+ readonly _tag = "InvalidInputError";
423
+ constructor(error: unknown);
424
+ }
425
+ type GetNonFungibleBalanceInput = {
426
+ addresses: string[];
427
+ at_ledger_state: AtLedgerState;
428
+ resourceAddresses?: string[];
429
+ options?: StateEntityDetailsOperationRequest['stateEntityDetailsRequest']['opt_ins'];
430
+ };
431
+ type GetNonFungibleBalanceOutput = Effect.Effect.Success<Awaited<ReturnType<(typeof GetNonFungibleBalanceService)['Service']>>>;
432
+ declare const GetNonFungibleBalanceService_base: Effect.Service.Class<GetNonFungibleBalanceService, "GetNonFungibleBalanceService", {
433
+ readonly dependencies: readonly [effect_Layer0.Layer<NonFungibleData, effect_ConfigError11.ConfigError, never>, effect_Layer0.Layer<GetNftResourceManagersService, effect_ConfigError11.ConfigError, never>];
434
+ readonly effect: Effect.Effect<(this: unknown, input: GetNonFungibleBalanceInput) => Effect.Effect<{
435
+ items: {
436
+ address: string;
437
+ nonFungibleResources: {
438
+ resourceAddress: string;
439
+ items: {
440
+ id: string;
441
+ lastUpdatedStateVersion: number;
442
+ sbor: _radixdlt_babylon_gateway_api_sdk6.ProgrammaticScryptoSborValue | undefined;
443
+ isBurned: boolean;
444
+ }[];
445
+ }[];
446
+ }[];
447
+ }, AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>, effect_ConfigError11.ConfigError, NonFungibleData | GetNftResourceManagersService>;
448
+ }>;
449
+ declare class GetNonFungibleBalanceService extends GetNonFungibleBalanceService_base {}
450
+ //#endregion
451
+ //#region src/getResourceHolders.d.ts
452
+ declare const GetResourceHoldersService_base: Effect.Service.Class<GetResourceHoldersService, "GetResourceHoldersService", {
453
+ readonly dependencies: readonly [effect_Layer0.Layer<GatewayApiClient, effect_ConfigError11.ConfigError, never>];
454
+ readonly effect: Effect.Effect<(this: unknown, input: {
455
+ resourceAddress: string;
456
+ cursor?: string;
457
+ }) => Effect.Effect<ResourceHoldersCollectionItem[], AccountLockerNotFoundError | InvalidRequestError | EntityNotFoundError | InternalServerError | InvalidEntityError | InvalidTransactionError | NotSyncedUpError | TransactionNotFoundError | ErrorResponse | RateLimitExceededError | ResponseError | UnknownGatewayError, never>, never, GatewayApiClient>;
458
+ }>;
459
+ declare class GetResourceHoldersService extends GetResourceHoldersService_base {}
460
+ //#endregion
461
+ export { AccountLockerNotFoundError, AtLedgerState, AtLedgerStateSchema, EntityFungiblesPage, EntityNonFungibleIdsPage, EntityNonFungiblesPage, EntityNotFoundError, ErrorResponse, GatewayApiClient, GetAddressByNonFungibleService, GetAddressByNonFungibleServiceInput, GetComponentStateService, GetEntityDetailsInput, GetEntityDetailsOptions, GetEntityDetailsState, GetEntityDetailsVaultAggregated, GetEntityDetailsVaultAggregatedParameters, GetFungibleBalance, GetFungibleBalanceOutput, GetKeyValueStoreService, GetLedgerStateInput, GetLedgerStateService, GetNftResourceManagersService, GetNonFungibleBalanceOutput, GetNonFungibleBalanceService, GetNonFungibleIdsInput, GetNonFungibleLocationService, GetResourceHoldersService, GetValidators, InternalServerError, InvalidComponentStateError, InvalidEntityError, InvalidInputError, InvalidRequestError, InvalidStateInputError, InvalidTransactionError, KeyValueStoreDataService, KeyValueStoreKeysService, NonFungibleData, NotSyncedUpError, RateLimitExceededError, ResponseError, StateVersion, StateVersionSchema, TimestampSchema, TransactionNotFoundError, UnknownGatewayError, Validator, ValidatorSchema, validateAtLedgerStateInput };