@aws-sdk/client-managedblockchain-query 3.901.0 → 3.907.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 (2) hide show
  1. package/dist-cjs/index.js +1013 -1270
  2. package/package.json +6 -6
package/dist-cjs/index.js CHANGED
@@ -1,1322 +1,1065 @@
1
- "use strict";
2
- var __defProp = Object.defineProperty;
3
- var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
4
- var __getOwnPropNames = Object.getOwnPropertyNames;
5
- var __hasOwnProp = Object.prototype.hasOwnProperty;
6
- var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
7
- var __export = (target, all) => {
8
- for (var name in all)
9
- __defProp(target, name, { get: all[name], enumerable: true });
1
+ 'use strict';
2
+
3
+ var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
4
+ var middlewareLogger = require('@aws-sdk/middleware-logger');
5
+ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
6
+ var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
7
+ var configResolver = require('@smithy/config-resolver');
8
+ var core = require('@smithy/core');
9
+ var middlewareContentLength = require('@smithy/middleware-content-length');
10
+ var middlewareEndpoint = require('@smithy/middleware-endpoint');
11
+ var middlewareRetry = require('@smithy/middleware-retry');
12
+ var smithyClient = require('@smithy/smithy-client');
13
+ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
14
+ var runtimeConfig = require('./runtimeConfig');
15
+ var regionConfigResolver = require('@aws-sdk/region-config-resolver');
16
+ var protocolHttp = require('@smithy/protocol-http');
17
+ var middlewareSerde = require('@smithy/middleware-serde');
18
+ var core$1 = require('@aws-sdk/core');
19
+
20
+ const resolveClientEndpointParameters = (options) => {
21
+ return Object.assign(options, {
22
+ useDualstackEndpoint: options.useDualstackEndpoint ?? false,
23
+ useFipsEndpoint: options.useFipsEndpoint ?? false,
24
+ defaultSigningName: "managedblockchain-query",
25
+ });
10
26
  };
11
- var __copyProps = (to, from, except, desc) => {
12
- if (from && typeof from === "object" || typeof from === "function") {
13
- for (let key of __getOwnPropNames(from))
14
- if (!__hasOwnProp.call(to, key) && key !== except)
15
- __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
16
- }
17
- return to;
27
+ const commonParams = {
28
+ UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
29
+ Endpoint: { type: "builtInParams", name: "endpoint" },
30
+ Region: { type: "builtInParams", name: "region" },
31
+ UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
18
32
  };
19
- var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
20
-
21
- // src/index.ts
22
- var index_exports = {};
23
- __export(index_exports, {
24
- AccessDeniedException: () => AccessDeniedException,
25
- BatchGetTokenBalanceCommand: () => BatchGetTokenBalanceCommand,
26
- ConfirmationStatus: () => ConfirmationStatus,
27
- ErrorType: () => ErrorType,
28
- ExecutionStatus: () => ExecutionStatus,
29
- GetAssetContractCommand: () => GetAssetContractCommand,
30
- GetTokenBalanceCommand: () => GetTokenBalanceCommand,
31
- GetTransactionCommand: () => GetTransactionCommand,
32
- InternalServerException: () => InternalServerException,
33
- ListAssetContractsCommand: () => ListAssetContractsCommand,
34
- ListFilteredTransactionEventsCommand: () => ListFilteredTransactionEventsCommand,
35
- ListFilteredTransactionEventsSortBy: () => ListFilteredTransactionEventsSortBy,
36
- ListTokenBalancesCommand: () => ListTokenBalancesCommand,
37
- ListTransactionEventsCommand: () => ListTransactionEventsCommand,
38
- ListTransactionsCommand: () => ListTransactionsCommand,
39
- ListTransactionsSortBy: () => ListTransactionsSortBy,
40
- ManagedBlockchainQuery: () => ManagedBlockchainQuery,
41
- ManagedBlockchainQueryClient: () => ManagedBlockchainQueryClient,
42
- ManagedBlockchainQueryServiceException: () => ManagedBlockchainQueryServiceException,
43
- QueryNetwork: () => QueryNetwork,
44
- QueryTokenStandard: () => QueryTokenStandard,
45
- QueryTransactionEventType: () => QueryTransactionEventType,
46
- ResourceNotFoundException: () => ResourceNotFoundException,
47
- ResourceType: () => ResourceType,
48
- ServiceQuotaExceededException: () => ServiceQuotaExceededException,
49
- SortOrder: () => SortOrder,
50
- ThrottlingException: () => ThrottlingException,
51
- ValidationException: () => ValidationException,
52
- ValidationExceptionReason: () => ValidationExceptionReason,
53
- __Client: () => import_smithy_client.Client,
54
- paginateListAssetContracts: () => paginateListAssetContracts,
55
- paginateListFilteredTransactionEvents: () => paginateListFilteredTransactionEvents,
56
- paginateListTokenBalances: () => paginateListTokenBalances,
57
- paginateListTransactionEvents: () => paginateListTransactionEvents,
58
- paginateListTransactions: () => paginateListTransactions
59
- });
60
- module.exports = __toCommonJS(index_exports);
61
-
62
- // src/ManagedBlockchainQueryClient.ts
63
- var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
64
- var import_middleware_logger = require("@aws-sdk/middleware-logger");
65
- var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
66
- var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
67
- var import_config_resolver = require("@smithy/config-resolver");
68
- var import_core = require("@smithy/core");
69
- var import_middleware_content_length = require("@smithy/middleware-content-length");
70
- var import_middleware_endpoint = require("@smithy/middleware-endpoint");
71
- var import_middleware_retry = require("@smithy/middleware-retry");
72
-
73
- var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
74
33
 
75
- // src/endpoint/EndpointParameters.ts
76
- var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
77
- return Object.assign(options, {
78
- useDualstackEndpoint: options.useDualstackEndpoint ?? false,
79
- useFipsEndpoint: options.useFipsEndpoint ?? false,
80
- defaultSigningName: "managedblockchain-query"
81
- });
82
- }, "resolveClientEndpointParameters");
83
- var commonParams = {
84
- UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
85
- Endpoint: { type: "builtInParams", name: "endpoint" },
86
- Region: { type: "builtInParams", name: "region" },
87
- UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
34
+ const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
35
+ const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
36
+ let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
37
+ let _credentials = runtimeConfig.credentials;
38
+ return {
39
+ setHttpAuthScheme(httpAuthScheme) {
40
+ const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
41
+ if (index === -1) {
42
+ _httpAuthSchemes.push(httpAuthScheme);
43
+ }
44
+ else {
45
+ _httpAuthSchemes.splice(index, 1, httpAuthScheme);
46
+ }
47
+ },
48
+ httpAuthSchemes() {
49
+ return _httpAuthSchemes;
50
+ },
51
+ setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
52
+ _httpAuthSchemeProvider = httpAuthSchemeProvider;
53
+ },
54
+ httpAuthSchemeProvider() {
55
+ return _httpAuthSchemeProvider;
56
+ },
57
+ setCredentials(credentials) {
58
+ _credentials = credentials;
59
+ },
60
+ credentials() {
61
+ return _credentials;
62
+ },
63
+ };
64
+ };
65
+ const resolveHttpAuthRuntimeConfig = (config) => {
66
+ return {
67
+ httpAuthSchemes: config.httpAuthSchemes(),
68
+ httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
69
+ credentials: config.credentials(),
70
+ };
88
71
  };
89
72
 
90
- // src/ManagedBlockchainQueryClient.ts
91
- var import_runtimeConfig = require("././runtimeConfig");
92
-
93
- // src/runtimeExtensions.ts
94
- var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
95
- var import_protocol_http = require("@smithy/protocol-http");
96
- var import_smithy_client = require("@smithy/smithy-client");
73
+ const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
74
+ const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
75
+ extensions.forEach((extension) => extension.configure(extensionConfiguration));
76
+ return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
77
+ };
97
78
 
98
- // src/auth/httpAuthExtensionConfiguration.ts
99
- var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
100
- const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
101
- let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
102
- let _credentials = runtimeConfig.credentials;
103
- return {
104
- setHttpAuthScheme(httpAuthScheme) {
105
- const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
106
- if (index === -1) {
107
- _httpAuthSchemes.push(httpAuthScheme);
108
- } else {
109
- _httpAuthSchemes.splice(index, 1, httpAuthScheme);
110
- }
111
- },
112
- httpAuthSchemes() {
113
- return _httpAuthSchemes;
114
- },
115
- setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
116
- _httpAuthSchemeProvider = httpAuthSchemeProvider;
117
- },
118
- httpAuthSchemeProvider() {
119
- return _httpAuthSchemeProvider;
120
- },
121
- setCredentials(credentials) {
122
- _credentials = credentials;
123
- },
124
- credentials() {
125
- return _credentials;
79
+ class ManagedBlockchainQueryClient extends smithyClient.Client {
80
+ config;
81
+ constructor(...[configuration]) {
82
+ const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
83
+ super(_config_0);
84
+ this.initConfig = _config_0;
85
+ const _config_1 = resolveClientEndpointParameters(_config_0);
86
+ const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
87
+ const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
88
+ const _config_4 = configResolver.resolveRegionConfig(_config_3);
89
+ const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
90
+ const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5);
91
+ const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
92
+ const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
93
+ this.config = _config_8;
94
+ this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
95
+ this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
96
+ this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
97
+ this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
98
+ this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
99
+ this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
100
+ this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
101
+ httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultManagedBlockchainQueryHttpAuthSchemeParametersProvider,
102
+ identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
103
+ "aws.auth#sigv4": config.credentials,
104
+ }),
105
+ }));
106
+ this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
126
107
  }
127
- };
128
- }, "getHttpAuthExtensionConfiguration");
129
- var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
130
- return {
131
- httpAuthSchemes: config.httpAuthSchemes(),
132
- httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
133
- credentials: config.credentials()
134
- };
135
- }, "resolveHttpAuthRuntimeConfig");
136
-
137
- // src/runtimeExtensions.ts
138
- var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
139
- const extensionConfiguration = Object.assign(
140
- (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),
141
- (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),
142
- (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),
143
- getHttpAuthExtensionConfiguration(runtimeConfig)
144
- );
145
- extensions.forEach((extension) => extension.configure(extensionConfiguration));
146
- return Object.assign(
147
- runtimeConfig,
148
- (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
149
- (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
150
- (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
151
- resolveHttpAuthRuntimeConfig(extensionConfiguration)
152
- );
153
- }, "resolveRuntimeExtensions");
108
+ destroy() {
109
+ super.destroy();
110
+ }
111
+ }
154
112
 
155
- // src/ManagedBlockchainQueryClient.ts
156
- var ManagedBlockchainQueryClient = class extends import_smithy_client.Client {
157
- static {
158
- __name(this, "ManagedBlockchainQueryClient");
159
- }
160
- /**
161
- * The resolved configuration of ManagedBlockchainQueryClient class. This is resolved and normalized from the {@link ManagedBlockchainQueryClientConfig | constructor configuration interface}.
162
- */
163
- config;
164
- constructor(...[configuration]) {
165
- const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
166
- super(_config_0);
167
- this.initConfig = _config_0;
168
- const _config_1 = resolveClientEndpointParameters(_config_0);
169
- const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
170
- const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
171
- const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
172
- const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
173
- const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
174
- const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
175
- const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
176
- this.config = _config_8;
177
- this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
178
- this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
179
- this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
180
- this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
181
- this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
182
- this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
183
- this.middlewareStack.use(
184
- (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
185
- httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultManagedBlockchainQueryHttpAuthSchemeParametersProvider,
186
- identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({
187
- "aws.auth#sigv4": config.credentials
188
- }), "identityProviderConfigProvider")
189
- })
190
- );
191
- this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
192
- }
193
- /**
194
- * Destroy underlying resources, like sockets. It's usually not necessary to do this.
195
- * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
196
- * Otherwise, sockets might stay open for quite a long time before the server terminates them.
197
- */
198
- destroy() {
199
- super.destroy();
200
- }
113
+ class ManagedBlockchainQueryServiceException extends smithyClient.ServiceException {
114
+ constructor(options) {
115
+ super(options);
116
+ Object.setPrototypeOf(this, ManagedBlockchainQueryServiceException.prototype);
117
+ }
118
+ }
119
+
120
+ class AccessDeniedException extends ManagedBlockchainQueryServiceException {
121
+ name = "AccessDeniedException";
122
+ $fault = "client";
123
+ constructor(opts) {
124
+ super({
125
+ name: "AccessDeniedException",
126
+ $fault: "client",
127
+ ...opts,
128
+ });
129
+ Object.setPrototypeOf(this, AccessDeniedException.prototype);
130
+ }
131
+ }
132
+ const QueryNetwork = {
133
+ BITCOIN_MAINNET: "BITCOIN_MAINNET",
134
+ BITCOIN_TESTNET: "BITCOIN_TESTNET",
135
+ ETHEREUM_MAINNET: "ETHEREUM_MAINNET",
136
+ ETHEREUM_SEPOLIA_TESTNET: "ETHEREUM_SEPOLIA_TESTNET",
201
137
  };
202
-
203
- // src/ManagedBlockchainQuery.ts
204
-
205
-
206
- // src/commands/BatchGetTokenBalanceCommand.ts
207
-
208
- var import_middleware_serde = require("@smithy/middleware-serde");
209
-
210
-
211
- // src/protocols/Aws_restJson1.ts
212
- var import_core2 = require("@aws-sdk/core");
213
-
214
-
215
-
216
- // src/models/ManagedBlockchainQueryServiceException.ts
217
-
218
- var ManagedBlockchainQueryServiceException = class _ManagedBlockchainQueryServiceException extends import_smithy_client.ServiceException {
219
- static {
220
- __name(this, "ManagedBlockchainQueryServiceException");
221
- }
222
- /**
223
- * @internal
224
- */
225
- constructor(options) {
226
- super(options);
227
- Object.setPrototypeOf(this, _ManagedBlockchainQueryServiceException.prototype);
228
- }
138
+ const QueryTokenStandard = {
139
+ ERC1155: "ERC1155",
140
+ ERC20: "ERC20",
141
+ ERC721: "ERC721",
142
+ };
143
+ const ErrorType = {
144
+ RESOURCE_NOT_FOUND_EXCEPTION: "RESOURCE_NOT_FOUND_EXCEPTION",
145
+ VALIDATION_EXCEPTION: "VALIDATION_EXCEPTION",
146
+ };
147
+ class InternalServerException extends ManagedBlockchainQueryServiceException {
148
+ name = "InternalServerException";
149
+ $fault = "server";
150
+ $retryable = {};
151
+ retryAfterSeconds;
152
+ constructor(opts) {
153
+ super({
154
+ name: "InternalServerException",
155
+ $fault: "server",
156
+ ...opts,
157
+ });
158
+ Object.setPrototypeOf(this, InternalServerException.prototype);
159
+ this.retryAfterSeconds = opts.retryAfterSeconds;
160
+ }
161
+ }
162
+ const ResourceType = {
163
+ COLLECTION: "collection",
164
+ };
165
+ class ResourceNotFoundException extends ManagedBlockchainQueryServiceException {
166
+ name = "ResourceNotFoundException";
167
+ $fault = "client";
168
+ resourceId;
169
+ resourceType;
170
+ constructor(opts) {
171
+ super({
172
+ name: "ResourceNotFoundException",
173
+ $fault: "client",
174
+ ...opts,
175
+ });
176
+ Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
177
+ this.resourceId = opts.resourceId;
178
+ this.resourceType = opts.resourceType;
179
+ }
180
+ }
181
+ class ServiceQuotaExceededException extends ManagedBlockchainQueryServiceException {
182
+ name = "ServiceQuotaExceededException";
183
+ $fault = "client";
184
+ resourceId;
185
+ resourceType;
186
+ serviceCode;
187
+ quotaCode;
188
+ constructor(opts) {
189
+ super({
190
+ name: "ServiceQuotaExceededException",
191
+ $fault: "client",
192
+ ...opts,
193
+ });
194
+ Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
195
+ this.resourceId = opts.resourceId;
196
+ this.resourceType = opts.resourceType;
197
+ this.serviceCode = opts.serviceCode;
198
+ this.quotaCode = opts.quotaCode;
199
+ }
200
+ }
201
+ class ThrottlingException extends ManagedBlockchainQueryServiceException {
202
+ name = "ThrottlingException";
203
+ $fault = "client";
204
+ $retryable = {
205
+ throttling: true,
206
+ };
207
+ serviceCode;
208
+ quotaCode;
209
+ retryAfterSeconds;
210
+ constructor(opts) {
211
+ super({
212
+ name: "ThrottlingException",
213
+ $fault: "client",
214
+ ...opts,
215
+ });
216
+ Object.setPrototypeOf(this, ThrottlingException.prototype);
217
+ this.serviceCode = opts.serviceCode;
218
+ this.quotaCode = opts.quotaCode;
219
+ this.retryAfterSeconds = opts.retryAfterSeconds;
220
+ }
221
+ }
222
+ const ValidationExceptionReason = {
223
+ CANNOT_PARSE: "cannotParse",
224
+ FIELD_VALIDATION_FAILED: "fieldValidationFailed",
225
+ OTHER: "other",
226
+ UNKNOWN_OPERATION: "unknownOperation",
227
+ };
228
+ class ValidationException extends ManagedBlockchainQueryServiceException {
229
+ name = "ValidationException";
230
+ $fault = "client";
231
+ reason;
232
+ fieldList;
233
+ constructor(opts) {
234
+ super({
235
+ name: "ValidationException",
236
+ $fault: "client",
237
+ ...opts,
238
+ });
239
+ Object.setPrototypeOf(this, ValidationException.prototype);
240
+ this.reason = opts.reason;
241
+ this.fieldList = opts.fieldList;
242
+ }
243
+ }
244
+ const ConfirmationStatus = {
245
+ FINAL: "FINAL",
246
+ NONFINAL: "NONFINAL",
247
+ };
248
+ const ExecutionStatus = {
249
+ FAILED: "FAILED",
250
+ SUCCEEDED: "SUCCEEDED",
251
+ };
252
+ const ListFilteredTransactionEventsSortBy = {
253
+ blockchainInstant: "blockchainInstant",
254
+ };
255
+ const SortOrder = {
256
+ ASCENDING: "ASCENDING",
257
+ DESCENDING: "DESCENDING",
258
+ };
259
+ const QueryTransactionEventType = {
260
+ BITCOIN_VIN: "BITCOIN_VIN",
261
+ BITCOIN_VOUT: "BITCOIN_VOUT",
262
+ ERC1155_TRANSFER: "ERC1155_TRANSFER",
263
+ ERC20_BURN: "ERC20_BURN",
264
+ ERC20_DEPOSIT: "ERC20_DEPOSIT",
265
+ ERC20_MINT: "ERC20_MINT",
266
+ ERC20_TRANSFER: "ERC20_TRANSFER",
267
+ ERC20_WITHDRAWAL: "ERC20_WITHDRAWAL",
268
+ ERC721_TRANSFER: "ERC721_TRANSFER",
269
+ ETH_TRANSFER: "ETH_TRANSFER",
270
+ INTERNAL_ETH_TRANSFER: "INTERNAL_ETH_TRANSFER",
271
+ };
272
+ const ListTransactionsSortBy = {
273
+ TRANSACTION_TIMESTAMP: "TRANSACTION_TIMESTAMP",
229
274
  };
230
275
 
231
- // src/models/models_0.ts
232
- var AccessDeniedException = class _AccessDeniedException extends ManagedBlockchainQueryServiceException {
233
- static {
234
- __name(this, "AccessDeniedException");
235
- }
236
- name = "AccessDeniedException";
237
- $fault = "client";
238
- /**
239
- * @internal
240
- */
241
- constructor(opts) {
242
- super({
243
- name: "AccessDeniedException",
244
- $fault: "client",
245
- ...opts
276
+ const se_BatchGetTokenBalanceCommand = async (input, context) => {
277
+ const b = core.requestBuilder(input, context);
278
+ const headers = {
279
+ "content-type": "application/json",
280
+ };
281
+ b.bp("/batch-get-token-balance");
282
+ let body;
283
+ body = JSON.stringify(smithyClient.take(input, {
284
+ getTokenBalanceInputs: (_) => se_GetTokenBalanceInputList(_),
285
+ }));
286
+ b.m("POST").h(headers).b(body);
287
+ return b.build();
288
+ };
289
+ const se_GetAssetContractCommand = async (input, context) => {
290
+ const b = core.requestBuilder(input, context);
291
+ const headers = {
292
+ "content-type": "application/json",
293
+ };
294
+ b.bp("/get-asset-contract");
295
+ let body;
296
+ body = JSON.stringify(smithyClient.take(input, {
297
+ contractIdentifier: (_) => smithyClient._json(_),
298
+ }));
299
+ b.m("POST").h(headers).b(body);
300
+ return b.build();
301
+ };
302
+ const se_GetTokenBalanceCommand = async (input, context) => {
303
+ const b = core.requestBuilder(input, context);
304
+ const headers = {
305
+ "content-type": "application/json",
306
+ };
307
+ b.bp("/get-token-balance");
308
+ let body;
309
+ body = JSON.stringify(smithyClient.take(input, {
310
+ atBlockchainInstant: (_) => se_BlockchainInstant(_),
311
+ ownerIdentifier: (_) => smithyClient._json(_),
312
+ tokenIdentifier: (_) => smithyClient._json(_),
313
+ }));
314
+ b.m("POST").h(headers).b(body);
315
+ return b.build();
316
+ };
317
+ const se_GetTransactionCommand = async (input, context) => {
318
+ const b = core.requestBuilder(input, context);
319
+ const headers = {
320
+ "content-type": "application/json",
321
+ };
322
+ b.bp("/get-transaction");
323
+ let body;
324
+ body = JSON.stringify(smithyClient.take(input, {
325
+ network: [],
326
+ transactionHash: [],
327
+ transactionId: [],
328
+ }));
329
+ b.m("POST").h(headers).b(body);
330
+ return b.build();
331
+ };
332
+ const se_ListAssetContractsCommand = async (input, context) => {
333
+ const b = core.requestBuilder(input, context);
334
+ const headers = {
335
+ "content-type": "application/json",
336
+ };
337
+ b.bp("/list-asset-contracts");
338
+ let body;
339
+ body = JSON.stringify(smithyClient.take(input, {
340
+ contractFilter: (_) => smithyClient._json(_),
341
+ maxResults: [],
342
+ nextToken: [],
343
+ }));
344
+ b.m("POST").h(headers).b(body);
345
+ return b.build();
346
+ };
347
+ const se_ListFilteredTransactionEventsCommand = async (input, context) => {
348
+ const b = core.requestBuilder(input, context);
349
+ const headers = {
350
+ "content-type": "application/json",
351
+ };
352
+ b.bp("/list-filtered-transaction-events");
353
+ let body;
354
+ body = JSON.stringify(smithyClient.take(input, {
355
+ addressIdentifierFilter: (_) => smithyClient._json(_),
356
+ confirmationStatusFilter: (_) => smithyClient._json(_),
357
+ maxResults: [],
358
+ network: [],
359
+ nextToken: [],
360
+ sort: (_) => smithyClient._json(_),
361
+ timeFilter: (_) => se_TimeFilter(_),
362
+ voutFilter: (_) => smithyClient._json(_),
363
+ }));
364
+ b.m("POST").h(headers).b(body);
365
+ return b.build();
366
+ };
367
+ const se_ListTokenBalancesCommand = async (input, context) => {
368
+ const b = core.requestBuilder(input, context);
369
+ const headers = {
370
+ "content-type": "application/json",
371
+ };
372
+ b.bp("/list-token-balances");
373
+ let body;
374
+ body = JSON.stringify(smithyClient.take(input, {
375
+ maxResults: [],
376
+ nextToken: [],
377
+ ownerFilter: (_) => smithyClient._json(_),
378
+ tokenFilter: (_) => smithyClient._json(_),
379
+ }));
380
+ b.m("POST").h(headers).b(body);
381
+ return b.build();
382
+ };
383
+ const se_ListTransactionEventsCommand = async (input, context) => {
384
+ const b = core.requestBuilder(input, context);
385
+ const headers = {
386
+ "content-type": "application/json",
387
+ };
388
+ b.bp("/list-transaction-events");
389
+ let body;
390
+ body = JSON.stringify(smithyClient.take(input, {
391
+ maxResults: [],
392
+ network: [],
393
+ nextToken: [],
394
+ transactionHash: [],
395
+ transactionId: [],
396
+ }));
397
+ b.m("POST").h(headers).b(body);
398
+ return b.build();
399
+ };
400
+ const se_ListTransactionsCommand = async (input, context) => {
401
+ const b = core.requestBuilder(input, context);
402
+ const headers = {
403
+ "content-type": "application/json",
404
+ };
405
+ b.bp("/list-transactions");
406
+ let body;
407
+ body = JSON.stringify(smithyClient.take(input, {
408
+ address: [],
409
+ confirmationStatusFilter: (_) => smithyClient._json(_),
410
+ fromBlockchainInstant: (_) => se_BlockchainInstant(_),
411
+ maxResults: [],
412
+ network: [],
413
+ nextToken: [],
414
+ sort: (_) => smithyClient._json(_),
415
+ toBlockchainInstant: (_) => se_BlockchainInstant(_),
416
+ }));
417
+ b.m("POST").h(headers).b(body);
418
+ return b.build();
419
+ };
420
+ const de_BatchGetTokenBalanceCommand = async (output, context) => {
421
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
422
+ return de_CommandError(output, context);
423
+ }
424
+ const contents = smithyClient.map({
425
+ $metadata: deserializeMetadata(output),
246
426
  });
247
- Object.setPrototypeOf(this, _AccessDeniedException.prototype);
248
- }
427
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
428
+ const doc = smithyClient.take(data, {
429
+ errors: (_) => de_BatchGetTokenBalanceErrors(_),
430
+ tokenBalances: (_) => de_BatchGetTokenBalanceOutputList(_),
431
+ });
432
+ Object.assign(contents, doc);
433
+ return contents;
249
434
  };
250
- var QueryNetwork = {
251
- /**
252
- * Bitcoin main network
253
- */
254
- BITCOIN_MAINNET: "BITCOIN_MAINNET",
255
- /**
256
- * Bitcoin test network
257
- */
258
- BITCOIN_TESTNET: "BITCOIN_TESTNET",
259
- /**
260
- * Ethereum main network
261
- */
262
- ETHEREUM_MAINNET: "ETHEREUM_MAINNET",
263
- /**
264
- * SEPOLIA network (ethereum testnet)
265
- */
266
- ETHEREUM_SEPOLIA_TESTNET: "ETHEREUM_SEPOLIA_TESTNET"
435
+ const de_GetAssetContractCommand = async (output, context) => {
436
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
437
+ return de_CommandError(output, context);
438
+ }
439
+ const contents = smithyClient.map({
440
+ $metadata: deserializeMetadata(output),
441
+ });
442
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
443
+ const doc = smithyClient.take(data, {
444
+ contractIdentifier: smithyClient._json,
445
+ deployerAddress: smithyClient.expectString,
446
+ metadata: smithyClient._json,
447
+ tokenStandard: smithyClient.expectString,
448
+ });
449
+ Object.assign(contents, doc);
450
+ return contents;
267
451
  };
268
- var QueryTokenStandard = {
269
- ERC1155: "ERC1155",
270
- ERC20: "ERC20",
271
- ERC721: "ERC721"
452
+ const de_GetTokenBalanceCommand = async (output, context) => {
453
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
454
+ return de_CommandError(output, context);
455
+ }
456
+ const contents = smithyClient.map({
457
+ $metadata: deserializeMetadata(output),
458
+ });
459
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
460
+ const doc = smithyClient.take(data, {
461
+ atBlockchainInstant: (_) => de_BlockchainInstant(_),
462
+ balance: smithyClient.expectString,
463
+ lastUpdatedTime: (_) => de_BlockchainInstant(_),
464
+ ownerIdentifier: smithyClient._json,
465
+ tokenIdentifier: smithyClient._json,
466
+ });
467
+ Object.assign(contents, doc);
468
+ return contents;
272
469
  };
273
- var ErrorType = {
274
- /**
275
- * An API request retrieving an item that can't be found
276
- */
277
- RESOURCE_NOT_FOUND_EXCEPTION: "RESOURCE_NOT_FOUND_EXCEPTION",
278
- /**
279
- * An API request validation exception
280
- */
281
- VALIDATION_EXCEPTION: "VALIDATION_EXCEPTION"
470
+ const de_GetTransactionCommand = async (output, context) => {
471
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
472
+ return de_CommandError(output, context);
473
+ }
474
+ const contents = smithyClient.map({
475
+ $metadata: deserializeMetadata(output),
476
+ });
477
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
478
+ const doc = smithyClient.take(data, {
479
+ transaction: (_) => de_Transaction(_),
480
+ });
481
+ Object.assign(contents, doc);
482
+ return contents;
282
483
  };
283
- var InternalServerException = class _InternalServerException extends ManagedBlockchainQueryServiceException {
284
- static {
285
- __name(this, "InternalServerException");
286
- }
287
- name = "InternalServerException";
288
- $fault = "server";
289
- $retryable = {};
290
- /**
291
- * <p>Specifies the <code>retryAfterSeconds</code> value.</p>
292
- * @public
293
- */
294
- retryAfterSeconds;
295
- /**
296
- * @internal
297
- */
298
- constructor(opts) {
299
- super({
300
- name: "InternalServerException",
301
- $fault: "server",
302
- ...opts
484
+ const de_ListAssetContractsCommand = async (output, context) => {
485
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
486
+ return de_CommandError(output, context);
487
+ }
488
+ const contents = smithyClient.map({
489
+ $metadata: deserializeMetadata(output),
490
+ });
491
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
492
+ const doc = smithyClient.take(data, {
493
+ contracts: smithyClient._json,
494
+ nextToken: smithyClient.expectString,
303
495
  });
304
- Object.setPrototypeOf(this, _InternalServerException.prototype);
305
- this.retryAfterSeconds = opts.retryAfterSeconds;
306
- }
496
+ Object.assign(contents, doc);
497
+ return contents;
307
498
  };
308
- var ResourceType = {
309
- COLLECTION: "collection"
499
+ const de_ListFilteredTransactionEventsCommand = async (output, context) => {
500
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
501
+ return de_CommandError(output, context);
502
+ }
503
+ const contents = smithyClient.map({
504
+ $metadata: deserializeMetadata(output),
505
+ });
506
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
507
+ const doc = smithyClient.take(data, {
508
+ events: (_) => de_TransactionEventList(_),
509
+ nextToken: smithyClient.expectString,
510
+ });
511
+ Object.assign(contents, doc);
512
+ return contents;
310
513
  };
311
- var ResourceNotFoundException = class _ResourceNotFoundException extends ManagedBlockchainQueryServiceException {
312
- static {
313
- __name(this, "ResourceNotFoundException");
314
- }
315
- name = "ResourceNotFoundException";
316
- $fault = "client";
317
- /**
318
- * <p>The <code>resourceId</code> of the resource that caused the exception.</p>
319
- * @public
320
- */
321
- resourceId;
322
- /**
323
- * <p>The <code>resourceType</code> of the resource that caused the exception.</p>
324
- * @public
325
- */
326
- resourceType;
327
- /**
328
- * @internal
329
- */
330
- constructor(opts) {
331
- super({
332
- name: "ResourceNotFoundException",
333
- $fault: "client",
334
- ...opts
514
+ const de_ListTokenBalancesCommand = async (output, context) => {
515
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
516
+ return de_CommandError(output, context);
517
+ }
518
+ const contents = smithyClient.map({
519
+ $metadata: deserializeMetadata(output),
335
520
  });
336
- Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
337
- this.resourceId = opts.resourceId;
338
- this.resourceType = opts.resourceType;
339
- }
521
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
522
+ const doc = smithyClient.take(data, {
523
+ nextToken: smithyClient.expectString,
524
+ tokenBalances: (_) => de_TokenBalanceList(_),
525
+ });
526
+ Object.assign(contents, doc);
527
+ return contents;
340
528
  };
341
- var ServiceQuotaExceededException = class _ServiceQuotaExceededException extends ManagedBlockchainQueryServiceException {
342
- static {
343
- __name(this, "ServiceQuotaExceededException");
344
- }
345
- name = "ServiceQuotaExceededException";
346
- $fault = "client";
347
- /**
348
- * <p>The <code>resourceId</code> of the resource that caused the exception.</p>
349
- * @public
350
- */
351
- resourceId;
352
- /**
353
- * <p>The <code>resourceType</code> of the resource that caused the exception.</p>
354
- * @public
355
- */
356
- resourceType;
357
- /**
358
- * <p>The container for the <code>serviceCode</code>.</p>
359
- * @public
360
- */
361
- serviceCode;
362
- /**
363
- * <p>The container for the <code>quotaCode</code>.</p>
364
- * @public
365
- */
366
- quotaCode;
367
- /**
368
- * @internal
369
- */
370
- constructor(opts) {
371
- super({
372
- name: "ServiceQuotaExceededException",
373
- $fault: "client",
374
- ...opts
529
+ const de_ListTransactionEventsCommand = async (output, context) => {
530
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
531
+ return de_CommandError(output, context);
532
+ }
533
+ const contents = smithyClient.map({
534
+ $metadata: deserializeMetadata(output),
375
535
  });
376
- Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
377
- this.resourceId = opts.resourceId;
378
- this.resourceType = opts.resourceType;
379
- this.serviceCode = opts.serviceCode;
380
- this.quotaCode = opts.quotaCode;
381
- }
536
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
537
+ const doc = smithyClient.take(data, {
538
+ events: (_) => de_TransactionEventList(_),
539
+ nextToken: smithyClient.expectString,
540
+ });
541
+ Object.assign(contents, doc);
542
+ return contents;
382
543
  };
383
- var ThrottlingException = class _ThrottlingException extends ManagedBlockchainQueryServiceException {
384
- static {
385
- __name(this, "ThrottlingException");
386
- }
387
- name = "ThrottlingException";
388
- $fault = "client";
389
- $retryable = {
390
- throttling: true
391
- };
392
- /**
393
- * <p>The container for the <code>serviceCode</code>.</p>
394
- * @public
395
- */
396
- serviceCode;
397
- /**
398
- * <p>The container for the <code>quotaCode</code>.</p>
399
- * @public
400
- */
401
- quotaCode;
402
- /**
403
- * <p>The container of the <code>retryAfterSeconds</code> value.</p>
404
- * @public
405
- */
406
- retryAfterSeconds;
407
- /**
408
- * @internal
409
- */
410
- constructor(opts) {
411
- super({
412
- name: "ThrottlingException",
413
- $fault: "client",
414
- ...opts
544
+ const de_ListTransactionsCommand = async (output, context) => {
545
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
546
+ return de_CommandError(output, context);
547
+ }
548
+ const contents = smithyClient.map({
549
+ $metadata: deserializeMetadata(output),
550
+ });
551
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
552
+ const doc = smithyClient.take(data, {
553
+ nextToken: smithyClient.expectString,
554
+ transactions: (_) => de_TransactionOutputList(_),
415
555
  });
416
- Object.setPrototypeOf(this, _ThrottlingException.prototype);
417
- this.serviceCode = opts.serviceCode;
418
- this.quotaCode = opts.quotaCode;
419
- this.retryAfterSeconds = opts.retryAfterSeconds;
420
- }
556
+ Object.assign(contents, doc);
557
+ return contents;
421
558
  };
422
- var ValidationExceptionReason = {
423
- CANNOT_PARSE: "cannotParse",
424
- FIELD_VALIDATION_FAILED: "fieldValidationFailed",
425
- OTHER: "other",
426
- UNKNOWN_OPERATION: "unknownOperation"
559
+ const de_CommandError = async (output, context) => {
560
+ const parsedOutput = {
561
+ ...output,
562
+ body: await core$1.parseJsonErrorBody(output.body, context),
563
+ };
564
+ const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
565
+ switch (errorCode) {
566
+ case "AccessDeniedException":
567
+ case "com.amazonaws.managedblockchainquery#AccessDeniedException":
568
+ throw await de_AccessDeniedExceptionRes(parsedOutput);
569
+ case "InternalServerException":
570
+ case "com.amazonaws.managedblockchainquery#InternalServerException":
571
+ throw await de_InternalServerExceptionRes(parsedOutput);
572
+ case "ResourceNotFoundException":
573
+ case "com.amazonaws.managedblockchainquery#ResourceNotFoundException":
574
+ throw await de_ResourceNotFoundExceptionRes(parsedOutput);
575
+ case "ServiceQuotaExceededException":
576
+ case "com.amazonaws.managedblockchainquery#ServiceQuotaExceededException":
577
+ throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
578
+ case "ThrottlingException":
579
+ case "com.amazonaws.managedblockchainquery#ThrottlingException":
580
+ throw await de_ThrottlingExceptionRes(parsedOutput);
581
+ case "ValidationException":
582
+ case "com.amazonaws.managedblockchainquery#ValidationException":
583
+ throw await de_ValidationExceptionRes(parsedOutput);
584
+ default:
585
+ const parsedBody = parsedOutput.body;
586
+ return throwDefaultError({
587
+ output,
588
+ parsedBody,
589
+ errorCode,
590
+ });
591
+ }
427
592
  };
428
- var ValidationException = class _ValidationException extends ManagedBlockchainQueryServiceException {
429
- static {
430
- __name(this, "ValidationException");
431
- }
432
- name = "ValidationException";
433
- $fault = "client";
434
- /**
435
- * <p>The container for the reason for the exception</p>
436
- * @public
437
- */
438
- reason;
439
- /**
440
- * <p>The container for the <code>fieldList</code> of the exception.</p>
441
- * @public
442
- */
443
- fieldList;
444
- /**
445
- * @internal
446
- */
447
- constructor(opts) {
448
- super({
449
- name: "ValidationException",
450
- $fault: "client",
451
- ...opts
593
+ const throwDefaultError = smithyClient.withBaseException(ManagedBlockchainQueryServiceException);
594
+ const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
595
+ const contents = smithyClient.map({});
596
+ const data = parsedOutput.body;
597
+ const doc = smithyClient.take(data, {
598
+ message: smithyClient.expectString,
599
+ });
600
+ Object.assign(contents, doc);
601
+ const exception = new AccessDeniedException({
602
+ $metadata: deserializeMetadata(parsedOutput),
603
+ ...contents,
452
604
  });
453
- Object.setPrototypeOf(this, _ValidationException.prototype);
454
- this.reason = opts.reason;
455
- this.fieldList = opts.fieldList;
456
- }
605
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
457
606
  };
458
- var ConfirmationStatus = {
459
- FINAL: "FINAL",
460
- NONFINAL: "NONFINAL"
607
+ const de_InternalServerExceptionRes = async (parsedOutput, context) => {
608
+ const contents = smithyClient.map({
609
+ [_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => smithyClient.strictParseInt32(parsedOutput.headers[_ra])],
610
+ });
611
+ const data = parsedOutput.body;
612
+ const doc = smithyClient.take(data, {
613
+ message: smithyClient.expectString,
614
+ });
615
+ Object.assign(contents, doc);
616
+ const exception = new InternalServerException({
617
+ $metadata: deserializeMetadata(parsedOutput),
618
+ ...contents,
619
+ });
620
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
461
621
  };
462
- var ExecutionStatus = {
463
- FAILED: "FAILED",
464
- SUCCEEDED: "SUCCEEDED"
622
+ const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
623
+ const contents = smithyClient.map({});
624
+ const data = parsedOutput.body;
625
+ const doc = smithyClient.take(data, {
626
+ message: smithyClient.expectString,
627
+ resourceId: smithyClient.expectString,
628
+ resourceType: smithyClient.expectString,
629
+ });
630
+ Object.assign(contents, doc);
631
+ const exception = new ResourceNotFoundException({
632
+ $metadata: deserializeMetadata(parsedOutput),
633
+ ...contents,
634
+ });
635
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
465
636
  };
466
- var ListFilteredTransactionEventsSortBy = {
467
- /**
468
- * Timestamp of a transaction
469
- */
470
- blockchainInstant: "blockchainInstant"
637
+ const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
638
+ const contents = smithyClient.map({});
639
+ const data = parsedOutput.body;
640
+ const doc = smithyClient.take(data, {
641
+ message: smithyClient.expectString,
642
+ quotaCode: smithyClient.expectString,
643
+ resourceId: smithyClient.expectString,
644
+ resourceType: smithyClient.expectString,
645
+ serviceCode: smithyClient.expectString,
646
+ });
647
+ Object.assign(contents, doc);
648
+ const exception = new ServiceQuotaExceededException({
649
+ $metadata: deserializeMetadata(parsedOutput),
650
+ ...contents,
651
+ });
652
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
471
653
  };
472
- var SortOrder = {
473
- /**
474
- * Result sorted in ascending order
475
- */
476
- ASCENDING: "ASCENDING",
477
- /**
478
- * Result sorted in descending order
479
- */
480
- DESCENDING: "DESCENDING"
654
+ const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
655
+ const contents = smithyClient.map({
656
+ [_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => smithyClient.strictParseInt32(parsedOutput.headers[_ra])],
657
+ });
658
+ const data = parsedOutput.body;
659
+ const doc = smithyClient.take(data, {
660
+ message: smithyClient.expectString,
661
+ quotaCode: smithyClient.expectString,
662
+ serviceCode: smithyClient.expectString,
663
+ });
664
+ Object.assign(contents, doc);
665
+ const exception = new ThrottlingException({
666
+ $metadata: deserializeMetadata(parsedOutput),
667
+ ...contents,
668
+ });
669
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
481
670
  };
482
- var QueryTransactionEventType = {
483
- /**
484
- * A Bitcoin Vin transfer type
485
- */
486
- BITCOIN_VIN: "BITCOIN_VIN",
487
- /**
488
- * A Bitcoin Vout transfer type
489
- */
490
- BITCOIN_VOUT: "BITCOIN_VOUT",
491
- /**
492
- * An ERC1155 transfer type
493
- */
494
- ERC1155_TRANSFER: "ERC1155_TRANSFER",
495
- /**
496
- * An ERC20_BURN transfer type
497
- */
498
- ERC20_BURN: "ERC20_BURN",
499
- /**
500
- * An ERC20_DEPOSIT transfer type
501
- */
502
- ERC20_DEPOSIT: "ERC20_DEPOSIT",
503
- /**
504
- * An ERC20_MINT transfer type
505
- */
506
- ERC20_MINT: "ERC20_MINT",
507
- /**
508
- * An ERC20 transfer type
509
- */
510
- ERC20_TRANSFER: "ERC20_TRANSFER",
511
- /**
512
- * An ERC20_WITHDRAWAL transfer type
513
- */
514
- ERC20_WITHDRAWAL: "ERC20_WITHDRAWAL",
515
- /**
516
- * An ERC721 transfer type
517
- */
518
- ERC721_TRANSFER: "ERC721_TRANSFER",
519
- /**
520
- * An ETH transfer type
521
- */
522
- ETH_TRANSFER: "ETH_TRANSFER",
523
- /**
524
- * An internal ETH transfer type
525
- */
526
- INTERNAL_ETH_TRANSFER: "INTERNAL_ETH_TRANSFER"
671
+ const de_ValidationExceptionRes = async (parsedOutput, context) => {
672
+ const contents = smithyClient.map({});
673
+ const data = parsedOutput.body;
674
+ const doc = smithyClient.take(data, {
675
+ fieldList: smithyClient._json,
676
+ message: smithyClient.expectString,
677
+ reason: smithyClient.expectString,
678
+ });
679
+ Object.assign(contents, doc);
680
+ const exception = new ValidationException({
681
+ $metadata: deserializeMetadata(parsedOutput),
682
+ ...contents,
683
+ });
684
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
527
685
  };
528
- var ListTransactionsSortBy = {
529
- /**
530
- * Timestamp of a transaction
531
- */
532
- TRANSACTION_TIMESTAMP: "TRANSACTION_TIMESTAMP"
686
+ const se_BatchGetTokenBalanceInputItem = (input, context) => {
687
+ return smithyClient.take(input, {
688
+ atBlockchainInstant: (_) => se_BlockchainInstant(_),
689
+ ownerIdentifier: smithyClient._json,
690
+ tokenIdentifier: smithyClient._json,
691
+ });
533
692
  };
534
-
535
- // src/protocols/Aws_restJson1.ts
536
- var se_BatchGetTokenBalanceCommand = /* @__PURE__ */ __name(async (input, context) => {
537
- const b = (0, import_core.requestBuilder)(input, context);
538
- const headers = {
539
- "content-type": "application/json"
540
- };
541
- b.bp("/batch-get-token-balance");
542
- let body;
543
- body = JSON.stringify(
544
- (0, import_smithy_client.take)(input, {
545
- getTokenBalanceInputs: /* @__PURE__ */ __name((_) => se_GetTokenBalanceInputList(_, context), "getTokenBalanceInputs")
546
- })
547
- );
548
- b.m("POST").h(headers).b(body);
549
- return b.build();
550
- }, "se_BatchGetTokenBalanceCommand");
551
- var se_GetAssetContractCommand = /* @__PURE__ */ __name(async (input, context) => {
552
- const b = (0, import_core.requestBuilder)(input, context);
553
- const headers = {
554
- "content-type": "application/json"
555
- };
556
- b.bp("/get-asset-contract");
557
- let body;
558
- body = JSON.stringify(
559
- (0, import_smithy_client.take)(input, {
560
- contractIdentifier: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "contractIdentifier")
561
- })
562
- );
563
- b.m("POST").h(headers).b(body);
564
- return b.build();
565
- }, "se_GetAssetContractCommand");
566
- var se_GetTokenBalanceCommand = /* @__PURE__ */ __name(async (input, context) => {
567
- const b = (0, import_core.requestBuilder)(input, context);
568
- const headers = {
569
- "content-type": "application/json"
570
- };
571
- b.bp("/get-token-balance");
572
- let body;
573
- body = JSON.stringify(
574
- (0, import_smithy_client.take)(input, {
575
- atBlockchainInstant: /* @__PURE__ */ __name((_) => se_BlockchainInstant(_, context), "atBlockchainInstant"),
576
- ownerIdentifier: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "ownerIdentifier"),
577
- tokenIdentifier: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "tokenIdentifier")
578
- })
579
- );
580
- b.m("POST").h(headers).b(body);
581
- return b.build();
582
- }, "se_GetTokenBalanceCommand");
583
- var se_GetTransactionCommand = /* @__PURE__ */ __name(async (input, context) => {
584
- const b = (0, import_core.requestBuilder)(input, context);
585
- const headers = {
586
- "content-type": "application/json"
587
- };
588
- b.bp("/get-transaction");
589
- let body;
590
- body = JSON.stringify(
591
- (0, import_smithy_client.take)(input, {
592
- network: [],
593
- transactionHash: [],
594
- transactionId: []
595
- })
596
- );
597
- b.m("POST").h(headers).b(body);
598
- return b.build();
599
- }, "se_GetTransactionCommand");
600
- var se_ListAssetContractsCommand = /* @__PURE__ */ __name(async (input, context) => {
601
- const b = (0, import_core.requestBuilder)(input, context);
602
- const headers = {
603
- "content-type": "application/json"
604
- };
605
- b.bp("/list-asset-contracts");
606
- let body;
607
- body = JSON.stringify(
608
- (0, import_smithy_client.take)(input, {
609
- contractFilter: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "contractFilter"),
610
- maxResults: [],
611
- nextToken: []
612
- })
613
- );
614
- b.m("POST").h(headers).b(body);
615
- return b.build();
616
- }, "se_ListAssetContractsCommand");
617
- var se_ListFilteredTransactionEventsCommand = /* @__PURE__ */ __name(async (input, context) => {
618
- const b = (0, import_core.requestBuilder)(input, context);
619
- const headers = {
620
- "content-type": "application/json"
621
- };
622
- b.bp("/list-filtered-transaction-events");
623
- let body;
624
- body = JSON.stringify(
625
- (0, import_smithy_client.take)(input, {
626
- addressIdentifierFilter: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "addressIdentifierFilter"),
627
- confirmationStatusFilter: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "confirmationStatusFilter"),
628
- maxResults: [],
629
- network: [],
630
- nextToken: [],
631
- sort: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "sort"),
632
- timeFilter: /* @__PURE__ */ __name((_) => se_TimeFilter(_, context), "timeFilter"),
633
- voutFilter: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "voutFilter")
634
- })
635
- );
636
- b.m("POST").h(headers).b(body);
637
- return b.build();
638
- }, "se_ListFilteredTransactionEventsCommand");
639
- var se_ListTokenBalancesCommand = /* @__PURE__ */ __name(async (input, context) => {
640
- const b = (0, import_core.requestBuilder)(input, context);
641
- const headers = {
642
- "content-type": "application/json"
643
- };
644
- b.bp("/list-token-balances");
645
- let body;
646
- body = JSON.stringify(
647
- (0, import_smithy_client.take)(input, {
648
- maxResults: [],
649
- nextToken: [],
650
- ownerFilter: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "ownerFilter"),
651
- tokenFilter: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "tokenFilter")
652
- })
653
- );
654
- b.m("POST").h(headers).b(body);
655
- return b.build();
656
- }, "se_ListTokenBalancesCommand");
657
- var se_ListTransactionEventsCommand = /* @__PURE__ */ __name(async (input, context) => {
658
- const b = (0, import_core.requestBuilder)(input, context);
659
- const headers = {
660
- "content-type": "application/json"
661
- };
662
- b.bp("/list-transaction-events");
663
- let body;
664
- body = JSON.stringify(
665
- (0, import_smithy_client.take)(input, {
666
- maxResults: [],
667
- network: [],
668
- nextToken: [],
669
- transactionHash: [],
670
- transactionId: []
671
- })
672
- );
673
- b.m("POST").h(headers).b(body);
674
- return b.build();
675
- }, "se_ListTransactionEventsCommand");
676
- var se_ListTransactionsCommand = /* @__PURE__ */ __name(async (input, context) => {
677
- const b = (0, import_core.requestBuilder)(input, context);
678
- const headers = {
679
- "content-type": "application/json"
680
- };
681
- b.bp("/list-transactions");
682
- let body;
683
- body = JSON.stringify(
684
- (0, import_smithy_client.take)(input, {
685
- address: [],
686
- confirmationStatusFilter: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "confirmationStatusFilter"),
687
- fromBlockchainInstant: /* @__PURE__ */ __name((_) => se_BlockchainInstant(_, context), "fromBlockchainInstant"),
688
- maxResults: [],
689
- network: [],
690
- nextToken: [],
691
- sort: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "sort"),
692
- toBlockchainInstant: /* @__PURE__ */ __name((_) => se_BlockchainInstant(_, context), "toBlockchainInstant")
693
- })
694
- );
695
- b.m("POST").h(headers).b(body);
696
- return b.build();
697
- }, "se_ListTransactionsCommand");
698
- var de_BatchGetTokenBalanceCommand = /* @__PURE__ */ __name(async (output, context) => {
699
- if (output.statusCode !== 200 && output.statusCode >= 300) {
700
- return de_CommandError(output, context);
701
- }
702
- const contents = (0, import_smithy_client.map)({
703
- $metadata: deserializeMetadata(output)
704
- });
705
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
706
- const doc = (0, import_smithy_client.take)(data, {
707
- errors: /* @__PURE__ */ __name((_) => de_BatchGetTokenBalanceErrors(_, context), "errors"),
708
- tokenBalances: /* @__PURE__ */ __name((_) => de_BatchGetTokenBalanceOutputList(_, context), "tokenBalances")
709
- });
710
- Object.assign(contents, doc);
711
- return contents;
712
- }, "de_BatchGetTokenBalanceCommand");
713
- var de_GetAssetContractCommand = /* @__PURE__ */ __name(async (output, context) => {
714
- if (output.statusCode !== 200 && output.statusCode >= 300) {
715
- return de_CommandError(output, context);
716
- }
717
- const contents = (0, import_smithy_client.map)({
718
- $metadata: deserializeMetadata(output)
719
- });
720
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
721
- const doc = (0, import_smithy_client.take)(data, {
722
- contractIdentifier: import_smithy_client._json,
723
- deployerAddress: import_smithy_client.expectString,
724
- metadata: import_smithy_client._json,
725
- tokenStandard: import_smithy_client.expectString
726
- });
727
- Object.assign(contents, doc);
728
- return contents;
729
- }, "de_GetAssetContractCommand");
730
- var de_GetTokenBalanceCommand = /* @__PURE__ */ __name(async (output, context) => {
731
- if (output.statusCode !== 200 && output.statusCode >= 300) {
732
- return de_CommandError(output, context);
733
- }
734
- const contents = (0, import_smithy_client.map)({
735
- $metadata: deserializeMetadata(output)
736
- });
737
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
738
- const doc = (0, import_smithy_client.take)(data, {
739
- atBlockchainInstant: /* @__PURE__ */ __name((_) => de_BlockchainInstant(_, context), "atBlockchainInstant"),
740
- balance: import_smithy_client.expectString,
741
- lastUpdatedTime: /* @__PURE__ */ __name((_) => de_BlockchainInstant(_, context), "lastUpdatedTime"),
742
- ownerIdentifier: import_smithy_client._json,
743
- tokenIdentifier: import_smithy_client._json
744
- });
745
- Object.assign(contents, doc);
746
- return contents;
747
- }, "de_GetTokenBalanceCommand");
748
- var de_GetTransactionCommand = /* @__PURE__ */ __name(async (output, context) => {
749
- if (output.statusCode !== 200 && output.statusCode >= 300) {
750
- return de_CommandError(output, context);
751
- }
752
- const contents = (0, import_smithy_client.map)({
753
- $metadata: deserializeMetadata(output)
754
- });
755
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
756
- const doc = (0, import_smithy_client.take)(data, {
757
- transaction: /* @__PURE__ */ __name((_) => de_Transaction(_, context), "transaction")
758
- });
759
- Object.assign(contents, doc);
760
- return contents;
761
- }, "de_GetTransactionCommand");
762
- var de_ListAssetContractsCommand = /* @__PURE__ */ __name(async (output, context) => {
763
- if (output.statusCode !== 200 && output.statusCode >= 300) {
764
- return de_CommandError(output, context);
765
- }
766
- const contents = (0, import_smithy_client.map)({
767
- $metadata: deserializeMetadata(output)
768
- });
769
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
770
- const doc = (0, import_smithy_client.take)(data, {
771
- contracts: import_smithy_client._json,
772
- nextToken: import_smithy_client.expectString
773
- });
774
- Object.assign(contents, doc);
775
- return contents;
776
- }, "de_ListAssetContractsCommand");
777
- var de_ListFilteredTransactionEventsCommand = /* @__PURE__ */ __name(async (output, context) => {
778
- if (output.statusCode !== 200 && output.statusCode >= 300) {
779
- return de_CommandError(output, context);
780
- }
781
- const contents = (0, import_smithy_client.map)({
782
- $metadata: deserializeMetadata(output)
783
- });
784
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
785
- const doc = (0, import_smithy_client.take)(data, {
786
- events: /* @__PURE__ */ __name((_) => de_TransactionEventList(_, context), "events"),
787
- nextToken: import_smithy_client.expectString
788
- });
789
- Object.assign(contents, doc);
790
- return contents;
791
- }, "de_ListFilteredTransactionEventsCommand");
792
- var de_ListTokenBalancesCommand = /* @__PURE__ */ __name(async (output, context) => {
793
- if (output.statusCode !== 200 && output.statusCode >= 300) {
794
- return de_CommandError(output, context);
795
- }
796
- const contents = (0, import_smithy_client.map)({
797
- $metadata: deserializeMetadata(output)
798
- });
799
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
800
- const doc = (0, import_smithy_client.take)(data, {
801
- nextToken: import_smithy_client.expectString,
802
- tokenBalances: /* @__PURE__ */ __name((_) => de_TokenBalanceList(_, context), "tokenBalances")
803
- });
804
- Object.assign(contents, doc);
805
- return contents;
806
- }, "de_ListTokenBalancesCommand");
807
- var de_ListTransactionEventsCommand = /* @__PURE__ */ __name(async (output, context) => {
808
- if (output.statusCode !== 200 && output.statusCode >= 300) {
809
- return de_CommandError(output, context);
810
- }
811
- const contents = (0, import_smithy_client.map)({
812
- $metadata: deserializeMetadata(output)
813
- });
814
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
815
- const doc = (0, import_smithy_client.take)(data, {
816
- events: /* @__PURE__ */ __name((_) => de_TransactionEventList(_, context), "events"),
817
- nextToken: import_smithy_client.expectString
818
- });
819
- Object.assign(contents, doc);
820
- return contents;
821
- }, "de_ListTransactionEventsCommand");
822
- var de_ListTransactionsCommand = /* @__PURE__ */ __name(async (output, context) => {
823
- if (output.statusCode !== 200 && output.statusCode >= 300) {
824
- return de_CommandError(output, context);
825
- }
826
- const contents = (0, import_smithy_client.map)({
827
- $metadata: deserializeMetadata(output)
828
- });
829
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
830
- const doc = (0, import_smithy_client.take)(data, {
831
- nextToken: import_smithy_client.expectString,
832
- transactions: /* @__PURE__ */ __name((_) => de_TransactionOutputList(_, context), "transactions")
833
- });
834
- Object.assign(contents, doc);
835
- return contents;
836
- }, "de_ListTransactionsCommand");
837
- var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
838
- const parsedOutput = {
839
- ...output,
840
- body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
841
- };
842
- const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
843
- switch (errorCode) {
844
- case "AccessDeniedException":
845
- case "com.amazonaws.managedblockchainquery#AccessDeniedException":
846
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
847
- case "InternalServerException":
848
- case "com.amazonaws.managedblockchainquery#InternalServerException":
849
- throw await de_InternalServerExceptionRes(parsedOutput, context);
850
- case "ResourceNotFoundException":
851
- case "com.amazonaws.managedblockchainquery#ResourceNotFoundException":
852
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
853
- case "ServiceQuotaExceededException":
854
- case "com.amazonaws.managedblockchainquery#ServiceQuotaExceededException":
855
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
856
- case "ThrottlingException":
857
- case "com.amazonaws.managedblockchainquery#ThrottlingException":
858
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
859
- case "ValidationException":
860
- case "com.amazonaws.managedblockchainquery#ValidationException":
861
- throw await de_ValidationExceptionRes(parsedOutput, context);
862
- default:
863
- const parsedBody = parsedOutput.body;
864
- return throwDefaultError({
865
- output,
866
- parsedBody,
867
- errorCode
868
- });
869
- }
870
- }, "de_CommandError");
871
- var throwDefaultError = (0, import_smithy_client.withBaseException)(ManagedBlockchainQueryServiceException);
872
- var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
873
- const contents = (0, import_smithy_client.map)({});
874
- const data = parsedOutput.body;
875
- const doc = (0, import_smithy_client.take)(data, {
876
- message: import_smithy_client.expectString
877
- });
878
- Object.assign(contents, doc);
879
- const exception = new AccessDeniedException({
880
- $metadata: deserializeMetadata(parsedOutput),
881
- ...contents
882
- });
883
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
884
- }, "de_AccessDeniedExceptionRes");
885
- var de_InternalServerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
886
- const contents = (0, import_smithy_client.map)({
887
- [_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => (0, import_smithy_client.strictParseInt32)(parsedOutput.headers[_ra])]
888
- });
889
- const data = parsedOutput.body;
890
- const doc = (0, import_smithy_client.take)(data, {
891
- message: import_smithy_client.expectString
892
- });
893
- Object.assign(contents, doc);
894
- const exception = new InternalServerException({
895
- $metadata: deserializeMetadata(parsedOutput),
896
- ...contents
897
- });
898
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
899
- }, "de_InternalServerExceptionRes");
900
- var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
901
- const contents = (0, import_smithy_client.map)({});
902
- const data = parsedOutput.body;
903
- const doc = (0, import_smithy_client.take)(data, {
904
- message: import_smithy_client.expectString,
905
- resourceId: import_smithy_client.expectString,
906
- resourceType: import_smithy_client.expectString
907
- });
908
- Object.assign(contents, doc);
909
- const exception = new ResourceNotFoundException({
910
- $metadata: deserializeMetadata(parsedOutput),
911
- ...contents
912
- });
913
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
914
- }, "de_ResourceNotFoundExceptionRes");
915
- var de_ServiceQuotaExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
916
- const contents = (0, import_smithy_client.map)({});
917
- const data = parsedOutput.body;
918
- const doc = (0, import_smithy_client.take)(data, {
919
- message: import_smithy_client.expectString,
920
- quotaCode: import_smithy_client.expectString,
921
- resourceId: import_smithy_client.expectString,
922
- resourceType: import_smithy_client.expectString,
923
- serviceCode: import_smithy_client.expectString
924
- });
925
- Object.assign(contents, doc);
926
- const exception = new ServiceQuotaExceededException({
927
- $metadata: deserializeMetadata(parsedOutput),
928
- ...contents
929
- });
930
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
931
- }, "de_ServiceQuotaExceededExceptionRes");
932
- var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
933
- const contents = (0, import_smithy_client.map)({
934
- [_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => (0, import_smithy_client.strictParseInt32)(parsedOutput.headers[_ra])]
935
- });
936
- const data = parsedOutput.body;
937
- const doc = (0, import_smithy_client.take)(data, {
938
- message: import_smithy_client.expectString,
939
- quotaCode: import_smithy_client.expectString,
940
- serviceCode: import_smithy_client.expectString
941
- });
942
- Object.assign(contents, doc);
943
- const exception = new ThrottlingException({
944
- $metadata: deserializeMetadata(parsedOutput),
945
- ...contents
946
- });
947
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
948
- }, "de_ThrottlingExceptionRes");
949
- var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
950
- const contents = (0, import_smithy_client.map)({});
951
- const data = parsedOutput.body;
952
- const doc = (0, import_smithy_client.take)(data, {
953
- fieldList: import_smithy_client._json,
954
- message: import_smithy_client.expectString,
955
- reason: import_smithy_client.expectString
956
- });
957
- Object.assign(contents, doc);
958
- const exception = new ValidationException({
959
- $metadata: deserializeMetadata(parsedOutput),
960
- ...contents
961
- });
962
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
963
- }, "de_ValidationExceptionRes");
964
- var se_BatchGetTokenBalanceInputItem = /* @__PURE__ */ __name((input, context) => {
965
- return (0, import_smithy_client.take)(input, {
966
- atBlockchainInstant: /* @__PURE__ */ __name((_) => se_BlockchainInstant(_, context), "atBlockchainInstant"),
967
- ownerIdentifier: import_smithy_client._json,
968
- tokenIdentifier: import_smithy_client._json
969
- });
970
- }, "se_BatchGetTokenBalanceInputItem");
971
- var se_BlockchainInstant = /* @__PURE__ */ __name((input, context) => {
972
- return (0, import_smithy_client.take)(input, {
973
- time: /* @__PURE__ */ __name((_) => _.getTime() / 1e3, "time")
974
- });
975
- }, "se_BlockchainInstant");
976
- var se_GetTokenBalanceInputList = /* @__PURE__ */ __name((input, context) => {
977
- return input.filter((e) => e != null).map((entry) => {
978
- return se_BatchGetTokenBalanceInputItem(entry, context);
979
- });
980
- }, "se_GetTokenBalanceInputList");
981
- var se_TimeFilter = /* @__PURE__ */ __name((input, context) => {
982
- return (0, import_smithy_client.take)(input, {
983
- from: /* @__PURE__ */ __name((_) => se_BlockchainInstant(_, context), "from"),
984
- to: /* @__PURE__ */ __name((_) => se_BlockchainInstant(_, context), "to")
985
- });
986
- }, "se_TimeFilter");
987
- var de_BatchGetTokenBalanceErrorItem = /* @__PURE__ */ __name((output, context) => {
988
- return (0, import_smithy_client.take)(output, {
989
- atBlockchainInstant: /* @__PURE__ */ __name((_) => de_BlockchainInstant(_, context), "atBlockchainInstant"),
990
- errorCode: import_smithy_client.expectString,
991
- errorMessage: import_smithy_client.expectString,
992
- errorType: import_smithy_client.expectString,
993
- ownerIdentifier: import_smithy_client._json,
994
- tokenIdentifier: import_smithy_client._json
995
- });
996
- }, "de_BatchGetTokenBalanceErrorItem");
997
- var de_BatchGetTokenBalanceErrors = /* @__PURE__ */ __name((output, context) => {
998
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
999
- return de_BatchGetTokenBalanceErrorItem(entry, context);
1000
- });
1001
- return retVal;
1002
- }, "de_BatchGetTokenBalanceErrors");
1003
- var de_BatchGetTokenBalanceOutputItem = /* @__PURE__ */ __name((output, context) => {
1004
- return (0, import_smithy_client.take)(output, {
1005
- atBlockchainInstant: /* @__PURE__ */ __name((_) => de_BlockchainInstant(_, context), "atBlockchainInstant"),
1006
- balance: import_smithy_client.expectString,
1007
- lastUpdatedTime: /* @__PURE__ */ __name((_) => de_BlockchainInstant(_, context), "lastUpdatedTime"),
1008
- ownerIdentifier: import_smithy_client._json,
1009
- tokenIdentifier: import_smithy_client._json
1010
- });
1011
- }, "de_BatchGetTokenBalanceOutputItem");
1012
- var de_BatchGetTokenBalanceOutputList = /* @__PURE__ */ __name((output, context) => {
1013
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1014
- return de_BatchGetTokenBalanceOutputItem(entry, context);
1015
- });
1016
- return retVal;
1017
- }, "de_BatchGetTokenBalanceOutputList");
1018
- var de_BlockchainInstant = /* @__PURE__ */ __name((output, context) => {
1019
- return (0, import_smithy_client.take)(output, {
1020
- time: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "time")
1021
- });
1022
- }, "de_BlockchainInstant");
1023
- var de_TokenBalance = /* @__PURE__ */ __name((output, context) => {
1024
- return (0, import_smithy_client.take)(output, {
1025
- atBlockchainInstant: /* @__PURE__ */ __name((_) => de_BlockchainInstant(_, context), "atBlockchainInstant"),
1026
- balance: import_smithy_client.expectString,
1027
- lastUpdatedTime: /* @__PURE__ */ __name((_) => de_BlockchainInstant(_, context), "lastUpdatedTime"),
1028
- ownerIdentifier: import_smithy_client._json,
1029
- tokenIdentifier: import_smithy_client._json
1030
- });
1031
- }, "de_TokenBalance");
1032
- var de_TokenBalanceList = /* @__PURE__ */ __name((output, context) => {
1033
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1034
- return de_TokenBalance(entry, context);
1035
- });
1036
- return retVal;
1037
- }, "de_TokenBalanceList");
1038
- var de_Transaction = /* @__PURE__ */ __name((output, context) => {
1039
- return (0, import_smithy_client.take)(output, {
1040
- blockHash: import_smithy_client.expectString,
1041
- blockNumber: import_smithy_client.expectString,
1042
- confirmationStatus: import_smithy_client.expectString,
1043
- contractAddress: import_smithy_client.expectString,
1044
- cumulativeGasUsed: import_smithy_client.expectString,
1045
- effectiveGasPrice: import_smithy_client.expectString,
1046
- executionStatus: import_smithy_client.expectString,
1047
- from: import_smithy_client.expectString,
1048
- gasUsed: import_smithy_client.expectString,
1049
- network: import_smithy_client.expectString,
1050
- numberOfTransactions: import_smithy_client.expectLong,
1051
- signatureR: import_smithy_client.expectString,
1052
- signatureS: import_smithy_client.expectString,
1053
- signatureV: import_smithy_client.expectInt32,
1054
- to: import_smithy_client.expectString,
1055
- transactionFee: import_smithy_client.expectString,
1056
- transactionHash: import_smithy_client.expectString,
1057
- transactionId: import_smithy_client.expectString,
1058
- transactionIndex: import_smithy_client.expectLong,
1059
- transactionTimestamp: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "transactionTimestamp")
1060
- });
1061
- }, "de_Transaction");
1062
- var de_TransactionEvent = /* @__PURE__ */ __name((output, context) => {
1063
- return (0, import_smithy_client.take)(output, {
1064
- blockchainInstant: /* @__PURE__ */ __name((_) => de_BlockchainInstant(_, context), "blockchainInstant"),
1065
- confirmationStatus: import_smithy_client.expectString,
1066
- contractAddress: import_smithy_client.expectString,
1067
- eventType: import_smithy_client.expectString,
1068
- from: import_smithy_client.expectString,
1069
- network: import_smithy_client.expectString,
1070
- spentVoutIndex: import_smithy_client.expectInt32,
1071
- spentVoutTransactionHash: import_smithy_client.expectString,
1072
- spentVoutTransactionId: import_smithy_client.expectString,
1073
- to: import_smithy_client.expectString,
1074
- tokenId: import_smithy_client.expectString,
1075
- transactionHash: import_smithy_client.expectString,
1076
- transactionId: import_smithy_client.expectString,
1077
- value: import_smithy_client.expectString,
1078
- voutIndex: import_smithy_client.expectInt32,
1079
- voutSpent: import_smithy_client.expectBoolean
1080
- });
1081
- }, "de_TransactionEvent");
1082
- var de_TransactionEventList = /* @__PURE__ */ __name((output, context) => {
1083
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1084
- return de_TransactionEvent(entry, context);
1085
- });
1086
- return retVal;
1087
- }, "de_TransactionEventList");
1088
- var de_TransactionOutputItem = /* @__PURE__ */ __name((output, context) => {
1089
- return (0, import_smithy_client.take)(output, {
1090
- confirmationStatus: import_smithy_client.expectString,
1091
- network: import_smithy_client.expectString,
1092
- transactionHash: import_smithy_client.expectString,
1093
- transactionId: import_smithy_client.expectString,
1094
- transactionTimestamp: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "transactionTimestamp")
1095
- });
1096
- }, "de_TransactionOutputItem");
1097
- var de_TransactionOutputList = /* @__PURE__ */ __name((output, context) => {
1098
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1099
- return de_TransactionOutputItem(entry, context);
1100
- });
1101
- return retVal;
1102
- }, "de_TransactionOutputList");
1103
- var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
1104
- httpStatusCode: output.statusCode,
1105
- requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
1106
- extendedRequestId: output.headers["x-amz-id-2"],
1107
- cfId: output.headers["x-amz-cf-id"]
1108
- }), "deserializeMetadata");
1109
- var _rAS = "retryAfterSeconds";
1110
- var _ra = "retry-after";
1111
-
1112
- // src/commands/BatchGetTokenBalanceCommand.ts
1113
- var BatchGetTokenBalanceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1114
- return [
1115
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1116
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1117
- ];
1118
- }).s("TietonChainQueryService", "BatchGetTokenBalance", {}).n("ManagedBlockchainQueryClient", "BatchGetTokenBalanceCommand").f(void 0, void 0).ser(se_BatchGetTokenBalanceCommand).de(de_BatchGetTokenBalanceCommand).build() {
1119
- static {
1120
- __name(this, "BatchGetTokenBalanceCommand");
1121
- }
693
+ const se_BlockchainInstant = (input, context) => {
694
+ return smithyClient.take(input, {
695
+ time: (_) => _.getTime() / 1_000,
696
+ });
1122
697
  };
1123
-
1124
- // src/commands/GetAssetContractCommand.ts
1125
-
1126
-
1127
-
1128
- var GetAssetContractCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1129
- return [
1130
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1131
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1132
- ];
1133
- }).s("TietonChainQueryService", "GetAssetContract", {}).n("ManagedBlockchainQueryClient", "GetAssetContractCommand").f(void 0, void 0).ser(se_GetAssetContractCommand).de(de_GetAssetContractCommand).build() {
1134
- static {
1135
- __name(this, "GetAssetContractCommand");
1136
- }
698
+ const se_GetTokenBalanceInputList = (input, context) => {
699
+ return input
700
+ .filter((e) => e != null)
701
+ .map((entry) => {
702
+ return se_BatchGetTokenBalanceInputItem(entry);
703
+ });
1137
704
  };
1138
-
1139
- // src/commands/GetTokenBalanceCommand.ts
1140
-
1141
-
1142
-
1143
- var GetTokenBalanceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1144
- return [
1145
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1146
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1147
- ];
1148
- }).s("TietonChainQueryService", "GetTokenBalance", {}).n("ManagedBlockchainQueryClient", "GetTokenBalanceCommand").f(void 0, void 0).ser(se_GetTokenBalanceCommand).de(de_GetTokenBalanceCommand).build() {
1149
- static {
1150
- __name(this, "GetTokenBalanceCommand");
1151
- }
705
+ const se_TimeFilter = (input, context) => {
706
+ return smithyClient.take(input, {
707
+ from: (_) => se_BlockchainInstant(_),
708
+ to: (_) => se_BlockchainInstant(_),
709
+ });
1152
710
  };
1153
-
1154
- // src/commands/GetTransactionCommand.ts
1155
-
1156
-
1157
-
1158
- var GetTransactionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1159
- return [
1160
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1161
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1162
- ];
1163
- }).s("TietonChainQueryService", "GetTransaction", {}).n("ManagedBlockchainQueryClient", "GetTransactionCommand").f(void 0, void 0).ser(se_GetTransactionCommand).de(de_GetTransactionCommand).build() {
1164
- static {
1165
- __name(this, "GetTransactionCommand");
1166
- }
711
+ const de_BatchGetTokenBalanceErrorItem = (output, context) => {
712
+ return smithyClient.take(output, {
713
+ atBlockchainInstant: (_) => de_BlockchainInstant(_),
714
+ errorCode: smithyClient.expectString,
715
+ errorMessage: smithyClient.expectString,
716
+ errorType: smithyClient.expectString,
717
+ ownerIdentifier: smithyClient._json,
718
+ tokenIdentifier: smithyClient._json,
719
+ });
1167
720
  };
1168
-
1169
- // src/commands/ListAssetContractsCommand.ts
1170
-
1171
-
1172
-
1173
- var ListAssetContractsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1174
- return [
1175
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1176
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1177
- ];
1178
- }).s("TietonChainQueryService", "ListAssetContracts", {}).n("ManagedBlockchainQueryClient", "ListAssetContractsCommand").f(void 0, void 0).ser(se_ListAssetContractsCommand).de(de_ListAssetContractsCommand).build() {
1179
- static {
1180
- __name(this, "ListAssetContractsCommand");
1181
- }
721
+ const de_BatchGetTokenBalanceErrors = (output, context) => {
722
+ const retVal = (output || [])
723
+ .filter((e) => e != null)
724
+ .map((entry) => {
725
+ return de_BatchGetTokenBalanceErrorItem(entry);
726
+ });
727
+ return retVal;
1182
728
  };
1183
-
1184
- // src/commands/ListFilteredTransactionEventsCommand.ts
1185
-
1186
-
1187
-
1188
- var ListFilteredTransactionEventsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1189
- return [
1190
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1191
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1192
- ];
1193
- }).s("TietonChainQueryService", "ListFilteredTransactionEvents", {}).n("ManagedBlockchainQueryClient", "ListFilteredTransactionEventsCommand").f(void 0, void 0).ser(se_ListFilteredTransactionEventsCommand).de(de_ListFilteredTransactionEventsCommand).build() {
1194
- static {
1195
- __name(this, "ListFilteredTransactionEventsCommand");
1196
- }
729
+ const de_BatchGetTokenBalanceOutputItem = (output, context) => {
730
+ return smithyClient.take(output, {
731
+ atBlockchainInstant: (_) => de_BlockchainInstant(_),
732
+ balance: smithyClient.expectString,
733
+ lastUpdatedTime: (_) => de_BlockchainInstant(_),
734
+ ownerIdentifier: smithyClient._json,
735
+ tokenIdentifier: smithyClient._json,
736
+ });
1197
737
  };
1198
-
1199
- // src/commands/ListTokenBalancesCommand.ts
1200
-
1201
-
1202
-
1203
- var ListTokenBalancesCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1204
- return [
1205
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1206
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1207
- ];
1208
- }).s("TietonChainQueryService", "ListTokenBalances", {}).n("ManagedBlockchainQueryClient", "ListTokenBalancesCommand").f(void 0, void 0).ser(se_ListTokenBalancesCommand).de(de_ListTokenBalancesCommand).build() {
1209
- static {
1210
- __name(this, "ListTokenBalancesCommand");
1211
- }
738
+ const de_BatchGetTokenBalanceOutputList = (output, context) => {
739
+ const retVal = (output || [])
740
+ .filter((e) => e != null)
741
+ .map((entry) => {
742
+ return de_BatchGetTokenBalanceOutputItem(entry);
743
+ });
744
+ return retVal;
1212
745
  };
1213
-
1214
- // src/commands/ListTransactionEventsCommand.ts
1215
-
1216
-
1217
-
1218
- var ListTransactionEventsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1219
- return [
1220
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1221
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1222
- ];
1223
- }).s("TietonChainQueryService", "ListTransactionEvents", {}).n("ManagedBlockchainQueryClient", "ListTransactionEventsCommand").f(void 0, void 0).ser(se_ListTransactionEventsCommand).de(de_ListTransactionEventsCommand).build() {
1224
- static {
1225
- __name(this, "ListTransactionEventsCommand");
1226
- }
746
+ const de_BlockchainInstant = (output, context) => {
747
+ return smithyClient.take(output, {
748
+ time: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
749
+ });
1227
750
  };
1228
-
1229
- // src/commands/ListTransactionsCommand.ts
1230
-
1231
-
1232
-
1233
- var ListTransactionsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1234
- return [
1235
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1236
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1237
- ];
1238
- }).s("TietonChainQueryService", "ListTransactions", {}).n("ManagedBlockchainQueryClient", "ListTransactionsCommand").f(void 0, void 0).ser(se_ListTransactionsCommand).de(de_ListTransactionsCommand).build() {
1239
- static {
1240
- __name(this, "ListTransactionsCommand");
1241
- }
751
+ const de_TokenBalance = (output, context) => {
752
+ return smithyClient.take(output, {
753
+ atBlockchainInstant: (_) => de_BlockchainInstant(_),
754
+ balance: smithyClient.expectString,
755
+ lastUpdatedTime: (_) => de_BlockchainInstant(_),
756
+ ownerIdentifier: smithyClient._json,
757
+ tokenIdentifier: smithyClient._json,
758
+ });
1242
759
  };
1243
-
1244
- // src/ManagedBlockchainQuery.ts
1245
- var commands = {
1246
- BatchGetTokenBalanceCommand,
1247
- GetAssetContractCommand,
1248
- GetTokenBalanceCommand,
1249
- GetTransactionCommand,
1250
- ListAssetContractsCommand,
1251
- ListFilteredTransactionEventsCommand,
1252
- ListTokenBalancesCommand,
1253
- ListTransactionEventsCommand,
1254
- ListTransactionsCommand
760
+ const de_TokenBalanceList = (output, context) => {
761
+ const retVal = (output || [])
762
+ .filter((e) => e != null)
763
+ .map((entry) => {
764
+ return de_TokenBalance(entry);
765
+ });
766
+ return retVal;
1255
767
  };
1256
- var ManagedBlockchainQuery = class extends ManagedBlockchainQueryClient {
1257
- static {
1258
- __name(this, "ManagedBlockchainQuery");
1259
- }
768
+ const de_Transaction = (output, context) => {
769
+ return smithyClient.take(output, {
770
+ blockHash: smithyClient.expectString,
771
+ blockNumber: smithyClient.expectString,
772
+ confirmationStatus: smithyClient.expectString,
773
+ contractAddress: smithyClient.expectString,
774
+ cumulativeGasUsed: smithyClient.expectString,
775
+ effectiveGasPrice: smithyClient.expectString,
776
+ executionStatus: smithyClient.expectString,
777
+ from: smithyClient.expectString,
778
+ gasUsed: smithyClient.expectString,
779
+ network: smithyClient.expectString,
780
+ numberOfTransactions: smithyClient.expectLong,
781
+ signatureR: smithyClient.expectString,
782
+ signatureS: smithyClient.expectString,
783
+ signatureV: smithyClient.expectInt32,
784
+ to: smithyClient.expectString,
785
+ transactionFee: smithyClient.expectString,
786
+ transactionHash: smithyClient.expectString,
787
+ transactionId: smithyClient.expectString,
788
+ transactionIndex: smithyClient.expectLong,
789
+ transactionTimestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
790
+ });
1260
791
  };
1261
- (0, import_smithy_client.createAggregatedClient)(commands, ManagedBlockchainQuery);
1262
-
1263
- // src/pagination/ListAssetContractsPaginator.ts
1264
-
1265
- var paginateListAssetContracts = (0, import_core.createPaginator)(ManagedBlockchainQueryClient, ListAssetContractsCommand, "nextToken", "nextToken", "maxResults");
1266
-
1267
- // src/pagination/ListFilteredTransactionEventsPaginator.ts
1268
-
1269
- var paginateListFilteredTransactionEvents = (0, import_core.createPaginator)(ManagedBlockchainQueryClient, ListFilteredTransactionEventsCommand, "nextToken", "nextToken", "maxResults");
1270
-
1271
- // src/pagination/ListTokenBalancesPaginator.ts
792
+ const de_TransactionEvent = (output, context) => {
793
+ return smithyClient.take(output, {
794
+ blockchainInstant: (_) => de_BlockchainInstant(_),
795
+ confirmationStatus: smithyClient.expectString,
796
+ contractAddress: smithyClient.expectString,
797
+ eventType: smithyClient.expectString,
798
+ from: smithyClient.expectString,
799
+ network: smithyClient.expectString,
800
+ spentVoutIndex: smithyClient.expectInt32,
801
+ spentVoutTransactionHash: smithyClient.expectString,
802
+ spentVoutTransactionId: smithyClient.expectString,
803
+ to: smithyClient.expectString,
804
+ tokenId: smithyClient.expectString,
805
+ transactionHash: smithyClient.expectString,
806
+ transactionId: smithyClient.expectString,
807
+ value: smithyClient.expectString,
808
+ voutIndex: smithyClient.expectInt32,
809
+ voutSpent: smithyClient.expectBoolean,
810
+ });
811
+ };
812
+ const de_TransactionEventList = (output, context) => {
813
+ const retVal = (output || [])
814
+ .filter((e) => e != null)
815
+ .map((entry) => {
816
+ return de_TransactionEvent(entry);
817
+ });
818
+ return retVal;
819
+ };
820
+ const de_TransactionOutputItem = (output, context) => {
821
+ return smithyClient.take(output, {
822
+ confirmationStatus: smithyClient.expectString,
823
+ network: smithyClient.expectString,
824
+ transactionHash: smithyClient.expectString,
825
+ transactionId: smithyClient.expectString,
826
+ transactionTimestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
827
+ });
828
+ };
829
+ const de_TransactionOutputList = (output, context) => {
830
+ const retVal = (output || [])
831
+ .filter((e) => e != null)
832
+ .map((entry) => {
833
+ return de_TransactionOutputItem(entry);
834
+ });
835
+ return retVal;
836
+ };
837
+ const deserializeMetadata = (output) => ({
838
+ httpStatusCode: output.statusCode,
839
+ requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
840
+ extendedRequestId: output.headers["x-amz-id-2"],
841
+ cfId: output.headers["x-amz-cf-id"],
842
+ });
843
+ const _rAS = "retryAfterSeconds";
844
+ const _ra = "retry-after";
845
+
846
+ class BatchGetTokenBalanceCommand extends smithyClient.Command
847
+ .classBuilder()
848
+ .ep(commonParams)
849
+ .m(function (Command, cs, config, o) {
850
+ return [
851
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
852
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
853
+ ];
854
+ })
855
+ .s("TietonChainQueryService", "BatchGetTokenBalance", {})
856
+ .n("ManagedBlockchainQueryClient", "BatchGetTokenBalanceCommand")
857
+ .f(void 0, void 0)
858
+ .ser(se_BatchGetTokenBalanceCommand)
859
+ .de(de_BatchGetTokenBalanceCommand)
860
+ .build() {
861
+ }
862
+
863
+ class GetAssetContractCommand extends smithyClient.Command
864
+ .classBuilder()
865
+ .ep(commonParams)
866
+ .m(function (Command, cs, config, o) {
867
+ return [
868
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
869
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
870
+ ];
871
+ })
872
+ .s("TietonChainQueryService", "GetAssetContract", {})
873
+ .n("ManagedBlockchainQueryClient", "GetAssetContractCommand")
874
+ .f(void 0, void 0)
875
+ .ser(se_GetAssetContractCommand)
876
+ .de(de_GetAssetContractCommand)
877
+ .build() {
878
+ }
879
+
880
+ class GetTokenBalanceCommand extends smithyClient.Command
881
+ .classBuilder()
882
+ .ep(commonParams)
883
+ .m(function (Command, cs, config, o) {
884
+ return [
885
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
886
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
887
+ ];
888
+ })
889
+ .s("TietonChainQueryService", "GetTokenBalance", {})
890
+ .n("ManagedBlockchainQueryClient", "GetTokenBalanceCommand")
891
+ .f(void 0, void 0)
892
+ .ser(se_GetTokenBalanceCommand)
893
+ .de(de_GetTokenBalanceCommand)
894
+ .build() {
895
+ }
896
+
897
+ class GetTransactionCommand extends smithyClient.Command
898
+ .classBuilder()
899
+ .ep(commonParams)
900
+ .m(function (Command, cs, config, o) {
901
+ return [
902
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
903
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
904
+ ];
905
+ })
906
+ .s("TietonChainQueryService", "GetTransaction", {})
907
+ .n("ManagedBlockchainQueryClient", "GetTransactionCommand")
908
+ .f(void 0, void 0)
909
+ .ser(se_GetTransactionCommand)
910
+ .de(de_GetTransactionCommand)
911
+ .build() {
912
+ }
913
+
914
+ class ListAssetContractsCommand extends smithyClient.Command
915
+ .classBuilder()
916
+ .ep(commonParams)
917
+ .m(function (Command, cs, config, o) {
918
+ return [
919
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
920
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
921
+ ];
922
+ })
923
+ .s("TietonChainQueryService", "ListAssetContracts", {})
924
+ .n("ManagedBlockchainQueryClient", "ListAssetContractsCommand")
925
+ .f(void 0, void 0)
926
+ .ser(se_ListAssetContractsCommand)
927
+ .de(de_ListAssetContractsCommand)
928
+ .build() {
929
+ }
930
+
931
+ class ListFilteredTransactionEventsCommand extends smithyClient.Command
932
+ .classBuilder()
933
+ .ep(commonParams)
934
+ .m(function (Command, cs, config, o) {
935
+ return [
936
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
937
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
938
+ ];
939
+ })
940
+ .s("TietonChainQueryService", "ListFilteredTransactionEvents", {})
941
+ .n("ManagedBlockchainQueryClient", "ListFilteredTransactionEventsCommand")
942
+ .f(void 0, void 0)
943
+ .ser(se_ListFilteredTransactionEventsCommand)
944
+ .de(de_ListFilteredTransactionEventsCommand)
945
+ .build() {
946
+ }
947
+
948
+ class ListTokenBalancesCommand extends smithyClient.Command
949
+ .classBuilder()
950
+ .ep(commonParams)
951
+ .m(function (Command, cs, config, o) {
952
+ return [
953
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
954
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
955
+ ];
956
+ })
957
+ .s("TietonChainQueryService", "ListTokenBalances", {})
958
+ .n("ManagedBlockchainQueryClient", "ListTokenBalancesCommand")
959
+ .f(void 0, void 0)
960
+ .ser(se_ListTokenBalancesCommand)
961
+ .de(de_ListTokenBalancesCommand)
962
+ .build() {
963
+ }
964
+
965
+ class ListTransactionEventsCommand extends smithyClient.Command
966
+ .classBuilder()
967
+ .ep(commonParams)
968
+ .m(function (Command, cs, config, o) {
969
+ return [
970
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
971
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
972
+ ];
973
+ })
974
+ .s("TietonChainQueryService", "ListTransactionEvents", {})
975
+ .n("ManagedBlockchainQueryClient", "ListTransactionEventsCommand")
976
+ .f(void 0, void 0)
977
+ .ser(se_ListTransactionEventsCommand)
978
+ .de(de_ListTransactionEventsCommand)
979
+ .build() {
980
+ }
981
+
982
+ class ListTransactionsCommand extends smithyClient.Command
983
+ .classBuilder()
984
+ .ep(commonParams)
985
+ .m(function (Command, cs, config, o) {
986
+ return [
987
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
988
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
989
+ ];
990
+ })
991
+ .s("TietonChainQueryService", "ListTransactions", {})
992
+ .n("ManagedBlockchainQueryClient", "ListTransactionsCommand")
993
+ .f(void 0, void 0)
994
+ .ser(se_ListTransactionsCommand)
995
+ .de(de_ListTransactionsCommand)
996
+ .build() {
997
+ }
998
+
999
+ const commands = {
1000
+ BatchGetTokenBalanceCommand,
1001
+ GetAssetContractCommand,
1002
+ GetTokenBalanceCommand,
1003
+ GetTransactionCommand,
1004
+ ListAssetContractsCommand,
1005
+ ListFilteredTransactionEventsCommand,
1006
+ ListTokenBalancesCommand,
1007
+ ListTransactionEventsCommand,
1008
+ ListTransactionsCommand,
1009
+ };
1010
+ class ManagedBlockchainQuery extends ManagedBlockchainQueryClient {
1011
+ }
1012
+ smithyClient.createAggregatedClient(commands, ManagedBlockchainQuery);
1272
1013
 
1273
- var paginateListTokenBalances = (0, import_core.createPaginator)(ManagedBlockchainQueryClient, ListTokenBalancesCommand, "nextToken", "nextToken", "maxResults");
1014
+ const paginateListAssetContracts = core.createPaginator(ManagedBlockchainQueryClient, ListAssetContractsCommand, "nextToken", "nextToken", "maxResults");
1274
1015
 
1275
- // src/pagination/ListTransactionEventsPaginator.ts
1016
+ const paginateListFilteredTransactionEvents = core.createPaginator(ManagedBlockchainQueryClient, ListFilteredTransactionEventsCommand, "nextToken", "nextToken", "maxResults");
1276
1017
 
1277
- var paginateListTransactionEvents = (0, import_core.createPaginator)(ManagedBlockchainQueryClient, ListTransactionEventsCommand, "nextToken", "nextToken", "maxResults");
1018
+ const paginateListTokenBalances = core.createPaginator(ManagedBlockchainQueryClient, ListTokenBalancesCommand, "nextToken", "nextToken", "maxResults");
1278
1019
 
1279
- // src/pagination/ListTransactionsPaginator.ts
1020
+ const paginateListTransactionEvents = core.createPaginator(ManagedBlockchainQueryClient, ListTransactionEventsCommand, "nextToken", "nextToken", "maxResults");
1280
1021
 
1281
- var paginateListTransactions = (0, import_core.createPaginator)(ManagedBlockchainQueryClient, ListTransactionsCommand, "nextToken", "nextToken", "maxResults");
1282
- // Annotate the CommonJS export names for ESM import in node:
1022
+ const paginateListTransactions = core.createPaginator(ManagedBlockchainQueryClient, ListTransactionsCommand, "nextToken", "nextToken", "maxResults");
1283
1023
 
1284
- 0 && (module.exports = {
1285
- ManagedBlockchainQueryServiceException,
1286
- __Client,
1287
- ManagedBlockchainQueryClient,
1288
- ManagedBlockchainQuery,
1289
- $Command,
1290
- BatchGetTokenBalanceCommand,
1291
- GetAssetContractCommand,
1292
- GetTokenBalanceCommand,
1293
- GetTransactionCommand,
1294
- ListAssetContractsCommand,
1295
- ListFilteredTransactionEventsCommand,
1296
- ListTokenBalancesCommand,
1297
- ListTransactionEventsCommand,
1298
- ListTransactionsCommand,
1299
- paginateListAssetContracts,
1300
- paginateListFilteredTransactionEvents,
1301
- paginateListTokenBalances,
1302
- paginateListTransactionEvents,
1303
- paginateListTransactions,
1304
- AccessDeniedException,
1305
- QueryNetwork,
1306
- QueryTokenStandard,
1307
- ErrorType,
1308
- InternalServerException,
1309
- ResourceType,
1310
- ResourceNotFoundException,
1311
- ServiceQuotaExceededException,
1312
- ThrottlingException,
1313
- ValidationExceptionReason,
1314
- ValidationException,
1315
- ConfirmationStatus,
1316
- ExecutionStatus,
1317
- ListFilteredTransactionEventsSortBy,
1318
- SortOrder,
1319
- QueryTransactionEventType,
1320
- ListTransactionsSortBy
1024
+ Object.defineProperty(exports, "$Command", {
1025
+ enumerable: true,
1026
+ get: function () { return smithyClient.Command; }
1321
1027
  });
1322
-
1028
+ Object.defineProperty(exports, "__Client", {
1029
+ enumerable: true,
1030
+ get: function () { return smithyClient.Client; }
1031
+ });
1032
+ exports.AccessDeniedException = AccessDeniedException;
1033
+ exports.BatchGetTokenBalanceCommand = BatchGetTokenBalanceCommand;
1034
+ exports.ConfirmationStatus = ConfirmationStatus;
1035
+ exports.ErrorType = ErrorType;
1036
+ exports.ExecutionStatus = ExecutionStatus;
1037
+ exports.GetAssetContractCommand = GetAssetContractCommand;
1038
+ exports.GetTokenBalanceCommand = GetTokenBalanceCommand;
1039
+ exports.GetTransactionCommand = GetTransactionCommand;
1040
+ exports.InternalServerException = InternalServerException;
1041
+ exports.ListAssetContractsCommand = ListAssetContractsCommand;
1042
+ exports.ListFilteredTransactionEventsCommand = ListFilteredTransactionEventsCommand;
1043
+ exports.ListFilteredTransactionEventsSortBy = ListFilteredTransactionEventsSortBy;
1044
+ exports.ListTokenBalancesCommand = ListTokenBalancesCommand;
1045
+ exports.ListTransactionEventsCommand = ListTransactionEventsCommand;
1046
+ exports.ListTransactionsCommand = ListTransactionsCommand;
1047
+ exports.ListTransactionsSortBy = ListTransactionsSortBy;
1048
+ exports.ManagedBlockchainQuery = ManagedBlockchainQuery;
1049
+ exports.ManagedBlockchainQueryClient = ManagedBlockchainQueryClient;
1050
+ exports.ManagedBlockchainQueryServiceException = ManagedBlockchainQueryServiceException;
1051
+ exports.QueryNetwork = QueryNetwork;
1052
+ exports.QueryTokenStandard = QueryTokenStandard;
1053
+ exports.QueryTransactionEventType = QueryTransactionEventType;
1054
+ exports.ResourceNotFoundException = ResourceNotFoundException;
1055
+ exports.ResourceType = ResourceType;
1056
+ exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
1057
+ exports.SortOrder = SortOrder;
1058
+ exports.ThrottlingException = ThrottlingException;
1059
+ exports.ValidationException = ValidationException;
1060
+ exports.ValidationExceptionReason = ValidationExceptionReason;
1061
+ exports.paginateListAssetContracts = paginateListAssetContracts;
1062
+ exports.paginateListFilteredTransactionEvents = paginateListFilteredTransactionEvents;
1063
+ exports.paginateListTokenBalances = paginateListTokenBalances;
1064
+ exports.paginateListTransactionEvents = paginateListTransactionEvents;
1065
+ exports.paginateListTransactions = paginateListTransactions;