diff --git a/CHANGELOG.md b/CHANGELOG.md
index 574bf9d16..43c055c12 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,18 @@
+## 1.8.2
+Release built: _not released yet_
+
+### Bug fixes
+- Fix processing multiple changes to single non fungible id data (`NonFungibleResourceManagerDataEntrySubstate`) in one batch. It might result in
+  - Wrong data stored and returned from the `/state/non-fungible/data` endpoint.
+  - Not tracking properly that non fungible id got deleted, which might lead to returning an invalid location of non fungible id. Affected endpoints are
+    - `/state/non-fungible/location`
+    - And all endpoints that return non fungible vault content 
+      - `/state/entity/details`
+      - `/state/entity/page/non-fungibles/`
+      - `/state/entity/page/non-fungible-vaults/`
+      - `/state/entity/page/non-fungible-vault/ids`
+
+
 ## 1.8.1
 Release built: 23.10.2024
 
diff --git a/Directory.Build.props b/Directory.Build.props
index 625ec2140..401ab4a32 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -14,7 +14,7 @@
   </PropertyGroup>
 
   <PropertyGroup>
-    <VersionPrefix>1.8.1</VersionPrefix>
+    <VersionPrefix>1.8.2</VersionPrefix>
     <VersionSuffix>develop</VersionSuffix>
   </PropertyGroup>
 
diff --git a/deployment/docker-compose.yml b/deployment/docker-compose.yml
index 85fbc21a7..808dd1112 100644
--- a/deployment/docker-compose.yml
+++ b/deployment/docker-compose.yml
@@ -51,13 +51,13 @@ services:
       retries: 3
 
   database_migrations: # This is the base -- the _image and _built containers are defined below
-    image: "radixdlt/babylon-ng-database-migrations:v1.8.1"
+    image: "radixdlt/babylon-ng-database-migrations:v1.8.2"
     profiles: ["NONE"]
     environment:
       ConnectionStrings__NetworkGatewayMigrations: "Host=postgres_db:5432;Database=${POSTGRES_DB_NAME};Username=${POSTGRES_SUPERUSER};Password=${POSTGRES_SUPERUSER_PASSWORD}"
 
   data_aggregator: # This is the base -- the _image and _built containers are defined below
-    image: "radixdlt/babylon-ng-data-aggregator:v1.8.1"
+    image: "radixdlt/babylon-ng-data-aggregator:v1.8.2"
     profiles: ["NONE"]
     deploy:
       restart_policy:
@@ -97,7 +97,7 @@ services:
       - ./data-aggregator-fixed-configuration.json:/home/radixdlt/network-gateway/config.json
 
   gateway_api: # This is the base -- the _image and _built containers are defined below
-    image: "radixdlt/babylon-ng-gateway-api:v1.8.1"
+    image: "radixdlt/babylon-ng-gateway-api:v1.8.2"
     profiles: ["NONE"]
     ports:
       - "127.0.0.1:5308:8080" # This allows you to connect to the API at http://localhost:5308
diff --git a/src/RadixDlt.NetworkGateway.GatewayApi/gateway-api-schema.yaml b/src/RadixDlt.NetworkGateway.GatewayApi/gateway-api-schema.yaml
index f58b9b911..14d4f775e 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApi/gateway-api-schema.yaml
+++ b/src/RadixDlt.NetworkGateway.GatewayApi/gateway-api-schema.yaml
@@ -1,6 +1,6 @@
 openapi: 3.0.0
 info:
-  version: v1.8.1
+  version: v1.8.2
   title: Radix Gateway API - Babylon
   license:
     name: The Radix License, Version 1.0
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Api/ExtensionsApi.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Api/ExtensionsApi.cs
index 6dd59aa51..9c8be6fd7 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Api/ExtensionsApi.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Api/ExtensionsApi.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Api/StateApi.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Api/StateApi.cs
index 4a94a6ec6..d9b70d245 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Api/StateApi.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Api/StateApi.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Api/StatisticsApi.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Api/StatisticsApi.cs
index ec415579d..21af5d7f4 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Api/StatisticsApi.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Api/StatisticsApi.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Api/StatusApi.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Api/StatusApi.cs
index 5e773b31e..8044fa837 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Api/StatusApi.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Api/StatusApi.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Api/StreamApi.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Api/StreamApi.cs
index 3426b997c..1641c4a90 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Api/StreamApi.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Api/StreamApi.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Api/TransactionApi.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Api/TransactionApi.cs
index 7535592fd..e58be85b5 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Api/TransactionApi.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Api/TransactionApi.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/ApiClient.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/ApiClient.cs
index 8aa4b8540..1060d8677 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/ApiClient.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/ApiClient.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/ApiException.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/ApiException.cs
index e67d13a58..7e26ad8a5 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/ApiException.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/ApiException.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/ApiResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/ApiResponse.cs
index a69e9a8e5..7b0d99145 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/ApiResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/ApiResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/ClientUtils.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/ClientUtils.cs
index 59bfddb63..395e6a78a 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/ClientUtils.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/ClientUtils.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/Configuration.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/Configuration.cs
index e822291de..99ea8d1be 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/Configuration.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/Configuration.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
@@ -591,7 +591,7 @@ public static string ToDebugReport()
             string report = "C# SDK (RadixDlt.NetworkGateway.GatewayApiSdk) Debug Report:\n";
             report += "    OS: " + System.Environment.OSVersion + "\n";
             report += "    .NET Framework Version: " + System.Environment.Version  + "\n";
-            report += "    Version of the API: v1.8.1\n";
+            report += "    Version of the API: v1.8.2\n";
             report += "    SDK Package Version: 1.0.0\n";
 
             return report;
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/ExceptionFactory.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/ExceptionFactory.cs
index 89060fcea..51757d5ce 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/ExceptionFactory.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/ExceptionFactory.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/FileParameter.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/FileParameter.cs
index b5e93192c..cda640913 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/FileParameter.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/FileParameter.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/GlobalConfiguration.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/GlobalConfiguration.cs
index f3f1621a2..e9cd8cfba 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/GlobalConfiguration.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/GlobalConfiguration.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/IApiAccessor.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/IApiAccessor.cs
index 62154b927..15820ab7f 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/IApiAccessor.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/IApiAccessor.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/IAsynchronousClient.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/IAsynchronousClient.cs
index 96c54fc1d..948419047 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/IAsynchronousClient.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/IAsynchronousClient.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/IReadableConfiguration.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/IReadableConfiguration.cs
index 4d5ca2e81..7d9daac81 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/IReadableConfiguration.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/IReadableConfiguration.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/ISynchronousClient.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/ISynchronousClient.cs
index d2fb1e258..d025140e4 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/ISynchronousClient.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/ISynchronousClient.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/Multimap.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/Multimap.cs
index ca1bf6c10..402d97ef2 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/Multimap.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/Multimap.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/OpenAPIDateConverter.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/OpenAPIDateConverter.cs
index e72c2ac0f..cbf52f5b0 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/OpenAPIDateConverter.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/OpenAPIDateConverter.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/RequestOptions.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/RequestOptions.cs
index 39b2d7730..361c6e83d 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/RequestOptions.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/RequestOptions.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/RetryConfiguration.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/RetryConfiguration.cs
index dfc3c648a..aa7182cee 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/RetryConfiguration.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/RetryConfiguration.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/WebRequestPathBuilder.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/WebRequestPathBuilder.cs
index 0dfc12de9..e34037b7f 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/WebRequestPathBuilder.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Client/WebRequestPathBuilder.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AbstractOpenAPISchema.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AbstractOpenAPISchema.cs
index 8f34ff931..ea42ffac3 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AbstractOpenAPISchema.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AbstractOpenAPISchema.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorBadgeType.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorBadgeType.cs
index a382c17d3..0b94cd4e2 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorBadgeType.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorBadgeType.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorsCollection.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorsCollection.cs
index 299ff1268..63b347a88 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorsCollection.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorsCollection.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorsCollectionAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorsCollectionAllOf.cs
index 3cfa813d5..ad10dedb4 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorsCollectionAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorsCollectionAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorsNonFungibleBadge.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorsNonFungibleBadge.cs
index cef7f4f11..d45c2fcd9 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorsNonFungibleBadge.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorsNonFungibleBadge.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorsNonFungibleBadgeAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorsNonFungibleBadgeAllOf.cs
index 84a049ee7..54766124d 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorsNonFungibleBadgeAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorsNonFungibleBadgeAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorsResourceBadge.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorsResourceBadge.cs
index 3fab67172..493d5359f 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorsResourceBadge.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorsResourceBadge.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorsResourceBadgeAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorsResourceBadgeAllOf.cs
index e03b9301f..7c570b51a 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorsResourceBadgeAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorsResourceBadgeAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorsResponseItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorsResponseItem.cs
index e3908b08c..3a46c65e8 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorsResponseItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountAuthorizedDepositorsResponseItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDefaultDepositRule.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDefaultDepositRule.cs
index 62295b2b8..a3993bdc5 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDefaultDepositRule.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDefaultDepositRule.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationDecidingFactors.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationDecidingFactors.cs
index 4c1390a98..3c9937d0c 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationDecidingFactors.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationDecidingFactors.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationDecidingFactorsResourceSpecificDetailsItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationDecidingFactorsResourceSpecificDetailsItem.cs
index 9cd6f7445..df4490157 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationDecidingFactorsResourceSpecificDetailsItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationDecidingFactorsResourceSpecificDetailsItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationNonFungibleBadge.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationNonFungibleBadge.cs
index 7e9f443c0..8e1c202a8 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationNonFungibleBadge.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationNonFungibleBadge.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationNonFungibleBadgeAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationNonFungibleBadgeAllOf.cs
index 9413d1bc5..65d3679a1 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationNonFungibleBadgeAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationNonFungibleBadgeAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationRequest.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationRequest.cs
index 724dc6988..9145dcfbb 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationRequest.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationRequest.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationRequestAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationRequestAllOf.cs
index 1e7d605d3..42752c735 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationRequestAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationRequestAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationResourceBadge.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationResourceBadge.cs
index 3c0279fb7..19dd1a699 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationResourceBadge.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationResourceBadge.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationResourceSpecificBehaviourItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationResourceSpecificBehaviourItem.cs
index d960af37a..2f1e31475 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationResourceSpecificBehaviourItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationResourceSpecificBehaviourItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationResponse.cs
index b5e947afb..955ab67ba 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationResponseAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationResponseAllOf.cs
index eadeca044..ab8353480 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationResponseAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountDepositPreValidationResponseAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerAddress.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerAddress.cs
index 53fcb4969..52b2ea20e 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerAddress.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerAddress.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerNotFoundError.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerNotFoundError.cs
index e41766476..ae3e70d0a 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerNotFoundError.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerNotFoundError.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollection.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollection.cs
index 841d3ede8..184a88654 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollection.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollection.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollectionAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollectionAllOf.cs
index 4e65f89d2..ba6941959 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollectionAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollectionAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollectionItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollectionItem.cs
index 23a1e7603..99807ae3e 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollectionItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollectionItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollectionItemFungible.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollectionItemFungible.cs
index 1244423b0..3f6504d87 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollectionItemFungible.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollectionItemFungible.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollectionItemFungibleAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollectionItemFungibleAllOf.cs
index fd0c5d9d2..f6845df20 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollectionItemFungibleAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollectionItemFungibleAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollectionItemNonFungible.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollectionItemNonFungible.cs
index 1d1863a9f..8be7aff71 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollectionItemNonFungible.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollectionItemNonFungible.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollectionItemNonFungibleAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollectionItemNonFungibleAllOf.cs
index 00ddd3d5b..f4ec8e54b 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollectionItemNonFungibleAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollectionItemNonFungibleAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollectionItemType.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollectionItemType.cs
index 35dd222d1..dd216a0ef 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollectionItemType.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountLockerVaultCollectionItemType.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountResourcePreferenceRule.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountResourcePreferenceRule.cs
index 81c799a53..76dbad085 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountResourcePreferenceRule.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountResourcePreferenceRule.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountResourcePreferencesCollection.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountResourcePreferencesCollection.cs
index 3121a9ec1..b38e31b51 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountResourcePreferencesCollection.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountResourcePreferencesCollection.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountResourcePreferencesCollectionAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountResourcePreferencesCollectionAllOf.cs
index b39b04861..6d9502720 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountResourcePreferencesCollectionAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountResourcePreferencesCollectionAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountResourcePreferencesResponseItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountResourcePreferencesResponseItem.cs
index 0282ad044..a33b5f70c 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountResourcePreferencesResponseItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AccountResourcePreferencesResponseItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AtLedgerStateMixin.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AtLedgerStateMixin.cs
index 2ab9a319f..22d388c14 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AtLedgerStateMixin.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/AtLedgerStateMixin.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/BlueprintMethodRoyalty.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/BlueprintMethodRoyalty.cs
index bd6b4defc..34b82b8d1 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/BlueprintMethodRoyalty.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/BlueprintMethodRoyalty.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/BlueprintRoyaltyConfig.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/BlueprintRoyaltyConfig.cs
index 74fd40286..d7354df60 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/BlueprintRoyaltyConfig.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/BlueprintRoyaltyConfig.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/CommittedTransactionInfo.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/CommittedTransactionInfo.cs
index f578585df..f47ca8768 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/CommittedTransactionInfo.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/CommittedTransactionInfo.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ComponentEntityRoleAssignmentEntry.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ComponentEntityRoleAssignmentEntry.cs
index eb8be1d5b..28225cdba 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ComponentEntityRoleAssignmentEntry.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ComponentEntityRoleAssignmentEntry.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ComponentEntityRoleAssignmentEntryAssignment.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ComponentEntityRoleAssignmentEntryAssignment.cs
index 74da73acc..56f572e2d 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ComponentEntityRoleAssignmentEntryAssignment.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ComponentEntityRoleAssignmentEntryAssignment.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ComponentEntityRoleAssignments.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ComponentEntityRoleAssignments.cs
index c14e373b6..7b0162f58 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ComponentEntityRoleAssignments.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ComponentEntityRoleAssignments.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ComponentMethodRoyalty.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ComponentMethodRoyalty.cs
index 01042d259..096d923f8 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ComponentMethodRoyalty.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ComponentMethodRoyalty.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ComponentRoyaltyConfig.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ComponentRoyaltyConfig.cs
index 3ab429b3d..0cb1e3bc2 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ComponentRoyaltyConfig.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ComponentRoyaltyConfig.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/CursorLimitMixin.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/CursorLimitMixin.cs
index baf9b1752..0b41415db 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/CursorLimitMixin.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/CursorLimitMixin.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntityMetadataCollection.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntityMetadataCollection.cs
index dcc760590..0c6e138f0 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntityMetadataCollection.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntityMetadataCollection.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntityMetadataCollectionAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntityMetadataCollectionAllOf.cs
index 7f06024fb..1fea2e12a 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntityMetadataCollectionAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntityMetadataCollectionAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntityMetadataItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntityMetadataItem.cs
index f56c27e47..e99a4e5bc 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntityMetadataItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntityMetadataItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntityMetadataItemValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntityMetadataItemValue.cs
index c82b2c998..038e5a3cf 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntityMetadataItemValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntityMetadataItemValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntityMetadataItemValueAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntityMetadataItemValueAllOf.cs
index 0d0ea30bd..26b0f8c3c 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntityMetadataItemValueAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntityMetadataItemValueAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntityNotFoundError.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntityNotFoundError.cs
index 793f26f52..db0fe5462 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntityNotFoundError.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntityNotFoundError.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntitySchemaCollection.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntitySchemaCollection.cs
index 6a3df973c..08fd6b136 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntitySchemaCollection.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntitySchemaCollection.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntitySchemaCollectionAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntitySchemaCollectionAllOf.cs
index 3353eac38..7b2d7f723 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntitySchemaCollectionAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntitySchemaCollectionAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntitySchemaCollectionItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntitySchemaCollectionItem.cs
index eaad0ff53..2504ceb75 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntitySchemaCollectionItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EntitySchemaCollectionItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ErrorResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ErrorResponse.cs
index be4930db6..d0b08c67e 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ErrorResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ErrorResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EventsItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EventsItem.cs
index e9c387f74..fcd02152e 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EventsItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/EventsItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FromLedgerStateMixin.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FromLedgerStateMixin.cs
index 61e79b155..4d2da7357 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FromLedgerStateMixin.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FromLedgerStateMixin.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollection.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollection.cs
index e9ee00feb..ce6cae287 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollection.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollection.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionAllOf.cs
index 77c86a0a5..eb7959ba5 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItem.cs
index 2c4d65933..c277c1b82 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItemGloballyAggregated.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItemGloballyAggregated.cs
index b23681b7b..c5bae2c51 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItemGloballyAggregated.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItemGloballyAggregated.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItemGloballyAggregatedAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItemGloballyAggregatedAllOf.cs
index d83c4a738..0b0320245 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItemGloballyAggregatedAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItemGloballyAggregatedAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItemVaultAggregated.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItemVaultAggregated.cs
index 5461abb30..c41bb875a 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItemVaultAggregated.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItemVaultAggregated.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItemVaultAggregatedAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItemVaultAggregatedAllOf.cs
index 533e88c09..c71fa5beb 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItemVaultAggregatedAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItemVaultAggregatedAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItemVaultAggregatedVault.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItemVaultAggregatedVault.cs
index 43a186d51..e75198817 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItemVaultAggregatedVault.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItemVaultAggregatedVault.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItemVaultAggregatedVaultAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItemVaultAggregatedVaultAllOf.cs
index d0572c5fa..98707ac56 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItemVaultAggregatedVaultAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItemVaultAggregatedVaultAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItemVaultAggregatedVaultItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItemVaultAggregatedVaultItem.cs
index 83eecb7d1..5bde3659f 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItemVaultAggregatedVaultItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/FungibleResourcesCollectionItemVaultAggregatedVaultItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/GatewayError.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/GatewayError.cs
index 04ddc9921..15ab217fd 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/GatewayError.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/GatewayError.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/GatewayInfoResponseKnownTarget.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/GatewayInfoResponseKnownTarget.cs
index 54176d463..938f01f28 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/GatewayInfoResponseKnownTarget.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/GatewayInfoResponseKnownTarget.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/GatewayInfoResponseReleaseInfo.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/GatewayInfoResponseReleaseInfo.cs
index eb711d373..7d544929d 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/GatewayInfoResponseReleaseInfo.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/GatewayInfoResponseReleaseInfo.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/GatewayStatusResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/GatewayStatusResponse.cs
index 7c86ac691..59a5f3bdd 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/GatewayStatusResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/GatewayStatusResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/GatewayStatusResponseAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/GatewayStatusResponseAllOf.cs
index 31de02250..a506b3498 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/GatewayStatusResponseAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/GatewayStatusResponseAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/InternalServerError.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/InternalServerError.cs
index 72df21757..5cd1d94c2 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/InternalServerError.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/InternalServerError.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/InternalServerErrorAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/InternalServerErrorAllOf.cs
index 338510e92..b15bef1ed 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/InternalServerErrorAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/InternalServerErrorAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/InvalidEntityError.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/InvalidEntityError.cs
index eb8f83571..a974f5e55 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/InvalidEntityError.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/InvalidEntityError.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/InvalidRequestError.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/InvalidRequestError.cs
index 98c529d24..d8b7cd103 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/InvalidRequestError.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/InvalidRequestError.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/InvalidRequestErrorAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/InvalidRequestErrorAllOf.cs
index 851a837b0..ecfff24b0 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/InvalidRequestErrorAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/InvalidRequestErrorAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/InvalidTransactionError.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/InvalidTransactionError.cs
index 872384b21..b0b24d6da 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/InvalidTransactionError.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/InvalidTransactionError.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/LedgerState.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/LedgerState.cs
index bc56687c2..a738306bd 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/LedgerState.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/LedgerState.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/LedgerStateMixin.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/LedgerStateMixin.cs
index 4f113411c..413b08544 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/LedgerStateMixin.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/LedgerStateMixin.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/LedgerStateSelector.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/LedgerStateSelector.cs
index df92b5eea..de3085808 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/LedgerStateSelector.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/LedgerStateSelector.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ManifestClass.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ManifestClass.cs
index aa24e3508..5a4348324 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ManifestClass.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ManifestClass.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataBoolArrayValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataBoolArrayValue.cs
index 709886e54..3ead3cc65 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataBoolArrayValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataBoolArrayValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataBoolArrayValueAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataBoolArrayValueAllOf.cs
index dc7efe7f6..e26c84c93 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataBoolArrayValueAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataBoolArrayValueAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataBoolValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataBoolValue.cs
index 4bf95e603..9fc0c661e 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataBoolValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataBoolValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataBoolValueAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataBoolValueAllOf.cs
index 518ce6ef7..19f835dbc 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataBoolValueAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataBoolValueAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataDecimalArrayValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataDecimalArrayValue.cs
index 24e2b6f34..6c69fc836 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataDecimalArrayValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataDecimalArrayValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataDecimalValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataDecimalValue.cs
index ab4741e38..3440e2618 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataDecimalValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataDecimalValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataGlobalAddressArrayValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataGlobalAddressArrayValue.cs
index 7a19253d7..edabda90b 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataGlobalAddressArrayValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataGlobalAddressArrayValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataGlobalAddressValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataGlobalAddressValue.cs
index d5a439820..0964b40a5 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataGlobalAddressValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataGlobalAddressValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataI32ArrayValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataI32ArrayValue.cs
index 306b75213..131d1f576 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataI32ArrayValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataI32ArrayValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataI32Value.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataI32Value.cs
index defda266d..2d700b11d 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataI32Value.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataI32Value.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataI64ArrayValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataI64ArrayValue.cs
index 32b061c04..799c102e6 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataI64ArrayValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataI64ArrayValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataI64Value.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataI64Value.cs
index 4dcdb2af1..9b7336480 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataI64Value.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataI64Value.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataInstantArrayValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataInstantArrayValue.cs
index 4766a8d3c..b10d86aa7 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataInstantArrayValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataInstantArrayValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataInstantArrayValueAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataInstantArrayValueAllOf.cs
index 6ebbc235a..1aabf960e 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataInstantArrayValueAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataInstantArrayValueAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataInstantValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataInstantValue.cs
index 57ecbe0d9..6dabddd5f 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataInstantValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataInstantValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataInstantValueAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataInstantValueAllOf.cs
index 2a1475b2b..8d38abef3 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataInstantValueAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataInstantValueAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataNonFungibleGlobalIdArrayValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataNonFungibleGlobalIdArrayValue.cs
index 2adc15550..11c64c304 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataNonFungibleGlobalIdArrayValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataNonFungibleGlobalIdArrayValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataNonFungibleGlobalIdArrayValueAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataNonFungibleGlobalIdArrayValueAllOf.cs
index b160c7386..c959d7874 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataNonFungibleGlobalIdArrayValueAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataNonFungibleGlobalIdArrayValueAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataNonFungibleGlobalIdValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataNonFungibleGlobalIdValue.cs
index d1c691bf2..532476c54 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataNonFungibleGlobalIdValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataNonFungibleGlobalIdValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataNonFungibleGlobalIdValueAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataNonFungibleGlobalIdValueAllOf.cs
index 4e3b770b9..867784f0d 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataNonFungibleGlobalIdValueAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataNonFungibleGlobalIdValueAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataNonFungibleLocalIdArrayValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataNonFungibleLocalIdArrayValue.cs
index 9d3ccec7f..bc989a8d7 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataNonFungibleLocalIdArrayValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataNonFungibleLocalIdArrayValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataNonFungibleLocalIdValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataNonFungibleLocalIdValue.cs
index 445d0f061..a278bb8f3 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataNonFungibleLocalIdValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataNonFungibleLocalIdValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataOriginArrayValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataOriginArrayValue.cs
index 7a4d95e8e..9cd05f6f5 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataOriginArrayValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataOriginArrayValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataOriginValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataOriginValue.cs
index 76fd7750b..7029c2a3c 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataOriginValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataOriginValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyArrayValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyArrayValue.cs
index 4d37a2d7e..ea1badd88 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyArrayValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyArrayValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyArrayValueAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyArrayValueAllOf.cs
index d7eff9436..265cb6913 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyArrayValueAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyArrayValueAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyHashArrayValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyHashArrayValue.cs
index 9780e97cb..5ce68309a 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyHashArrayValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyHashArrayValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyHashArrayValueAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyHashArrayValueAllOf.cs
index fe5d0a351..ef5bdec69 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyHashArrayValueAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyHashArrayValueAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyHashValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyHashValue.cs
index 8790dbb2d..5a0f0e018 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyHashValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyHashValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyHashValueAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyHashValueAllOf.cs
index b29a501e1..76555134c 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyHashValueAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyHashValueAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyValue.cs
index 844190f73..16906bd05 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyValueAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyValueAllOf.cs
index 99d03e26c..9f29670ea 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyValueAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataPublicKeyValueAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataStringArrayValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataStringArrayValue.cs
index e70330460..8a8d0e7d8 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataStringArrayValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataStringArrayValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataStringArrayValueAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataStringArrayValueAllOf.cs
index 359861649..58bb68c2d 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataStringArrayValueAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataStringArrayValueAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataStringValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataStringValue.cs
index 1e41d3f73..38cbd3a94 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataStringValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataStringValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataStringValueAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataStringValueAllOf.cs
index 14beed3f4..cc5e69f7c 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataStringValueAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataStringValueAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataTypedValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataTypedValue.cs
index d87740b75..4051f5b88 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataTypedValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataTypedValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataU32ArrayValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataU32ArrayValue.cs
index 9ab5d9359..cdd9a21e5 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataU32ArrayValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataU32ArrayValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataU32Value.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataU32Value.cs
index 5ad89e405..d7b00cff9 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataU32Value.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataU32Value.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataU64ArrayValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataU64ArrayValue.cs
index 326021d58..7aab737cb 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataU64ArrayValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataU64ArrayValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataU64Value.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataU64Value.cs
index a093610cf..de3ca8f90 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataU64Value.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataU64Value.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataU8ArrayValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataU8ArrayValue.cs
index fab4c69d2..96187654b 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataU8ArrayValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataU8ArrayValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataU8ArrayValueAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataU8ArrayValueAllOf.cs
index a90653e13..a9dc8bcfc 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataU8ArrayValueAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataU8ArrayValueAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataU8Value.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataU8Value.cs
index 4cea085fd..ad47d581e 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataU8Value.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataU8Value.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataUrlArrayValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataUrlArrayValue.cs
index 9bb61a444..066d1f9c0 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataUrlArrayValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataUrlArrayValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataUrlValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataUrlValue.cs
index 32db981c4..d1539fa9e 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataUrlValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataUrlValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataValueType.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataValueType.cs
index 6e2bb376a..205933fa1 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataValueType.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/MetadataValueType.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceAccessControllerRecoveryBadgeValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceAccessControllerRecoveryBadgeValue.cs
index f335e7d58..0eea30728 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceAccessControllerRecoveryBadgeValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceAccessControllerRecoveryBadgeValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceAccessControllerRecoveryBadgeValueAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceAccessControllerRecoveryBadgeValueAllOf.cs
index 598a41a21..650c36397 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceAccessControllerRecoveryBadgeValueAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceAccessControllerRecoveryBadgeValueAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceAccountOwnerBadgeValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceAccountOwnerBadgeValue.cs
index 5e175e7af..df7bc8941 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceAccountOwnerBadgeValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceAccountOwnerBadgeValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceDetails.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceDetails.cs
index bf26b0619..f5e4f5450 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceDetails.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceDetails.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceEd25519SignatureResourceValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceEd25519SignatureResourceValue.cs
index 86129da56..e5b41e659 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceEd25519SignatureResourceValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceEd25519SignatureResourceValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceGlobalCallerResourceValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceGlobalCallerResourceValue.cs
index a8d492dd5..2cee2d2a6 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceGlobalCallerResourceValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceGlobalCallerResourceValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceIdentityOwnerBadgeValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceIdentityOwnerBadgeValue.cs
index 708aee6da..65bcee2f5 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceIdentityOwnerBadgeValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceIdentityOwnerBadgeValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceKind.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceKind.cs
index 8095cc2b8..6b3b70fc3 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceKind.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceKind.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceMultiResourcePoolUnitValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceMultiResourcePoolUnitValue.cs
index 30309eae9..bdbb18f05 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceMultiResourcePoolUnitValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceMultiResourcePoolUnitValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceOneResourcePoolUnitValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceOneResourcePoolUnitValue.cs
index eb079f3f3..9f80f198d 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceOneResourcePoolUnitValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceOneResourcePoolUnitValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceOneResourcePoolUnitValueAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceOneResourcePoolUnitValueAllOf.cs
index 9f3c283d2..06ef0056b 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceOneResourcePoolUnitValueAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceOneResourcePoolUnitValueAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourcePackageOfDirectCallerResourceValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourcePackageOfDirectCallerResourceValue.cs
index 0beb00ad7..d129ceb51 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourcePackageOfDirectCallerResourceValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourcePackageOfDirectCallerResourceValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourcePackageOwnerBadgeValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourcePackageOwnerBadgeValue.cs
index de4cc095a..49ea9aec7 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourcePackageOwnerBadgeValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourcePackageOwnerBadgeValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceRedemptionValueItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceRedemptionValueItem.cs
index 7d74be48f..0c702cb99 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceRedemptionValueItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceRedemptionValueItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceSecp256k1SignatureResourceValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceSecp256k1SignatureResourceValue.cs
index 7ed4892b3..5a5fb6a99 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceSecp256k1SignatureResourceValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceSecp256k1SignatureResourceValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceSystemExecutionResourceValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceSystemExecutionResourceValue.cs
index 1bce7feea..936b22cfd 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceSystemExecutionResourceValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceSystemExecutionResourceValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceTwoResourcePoolUnitValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceTwoResourcePoolUnitValue.cs
index 49626f0b1..0a5f0cf4d 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceTwoResourcePoolUnitValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceTwoResourcePoolUnitValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceValidatorClaimNFTValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceValidatorClaimNFTValue.cs
index cdb65b6ce..598e0d05b 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceValidatorClaimNFTValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceValidatorClaimNFTValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceValidatorClaimNFTValueAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceValidatorClaimNFTValueAllOf.cs
index a2e34ee4a..5635132a2 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceValidatorClaimNFTValueAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceValidatorClaimNFTValueAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceValidatorLiquidStakeUnitValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceValidatorLiquidStakeUnitValue.cs
index 3f151109d..d0f20ad8b 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceValidatorLiquidStakeUnitValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceValidatorLiquidStakeUnitValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceValidatorLiquidStakeUnitValueAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceValidatorLiquidStakeUnitValueAllOf.cs
index 423b5c907..3c550ab75 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceValidatorLiquidStakeUnitValueAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceValidatorLiquidStakeUnitValueAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceValidatorOwnerBadgeValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceValidatorOwnerBadgeValue.cs
index 7941ad92a..c7f6979f6 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceValidatorOwnerBadgeValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceValidatorOwnerBadgeValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceXrdValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceXrdValue.cs
index 967223748..bbcd9506c 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceXrdValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NativeResourceXrdValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NetworkConfigurationResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NetworkConfigurationResponse.cs
index 066216fc2..d291ea94b 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NetworkConfigurationResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NetworkConfigurationResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NetworkConfigurationResponseWellKnownAddresses.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NetworkConfigurationResponseWellKnownAddresses.cs
index 5022b2576..1ad5e5e76 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NetworkConfigurationResponseWellKnownAddresses.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NetworkConfigurationResponseWellKnownAddresses.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleIdType.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleIdType.cs
index 719538bdd..3539ab160 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleIdType.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleIdType.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleIdsCollection.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleIdsCollection.cs
index 873481ce3..19bb836f3 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleIdsCollection.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleIdsCollection.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleIdsCollectionAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleIdsCollectionAllOf.cs
index d72e6d70f..82893cb8b 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleIdsCollectionAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleIdsCollectionAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollection.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollection.cs
index 4b908a4e9..c512aa54e 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollection.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollection.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionAllOf.cs
index 9899809f9..6280b99e8 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItem.cs
index 16fcfcd54..49687df94 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemGloballyAggregated.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemGloballyAggregated.cs
index c2148358d..850e5bc28 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemGloballyAggregated.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemGloballyAggregated.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemGloballyAggregatedAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemGloballyAggregatedAllOf.cs
index aba3dab3e..0ade123c4 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemGloballyAggregatedAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemGloballyAggregatedAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemVaultAggregated.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemVaultAggregated.cs
index 49c1dece9..51665c701 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemVaultAggregated.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemVaultAggregated.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemVaultAggregatedAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemVaultAggregatedAllOf.cs
index bb11d2119..071814b98 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemVaultAggregatedAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemVaultAggregatedAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemVaultAggregatedVault.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemVaultAggregatedVault.cs
index 08492e36f..6055c4f1a 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemVaultAggregatedVault.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemVaultAggregatedVault.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemVaultAggregatedVaultAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemVaultAggregatedVaultAllOf.cs
index 4c55906c1..da48718ee 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemVaultAggregatedVaultAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemVaultAggregatedVaultAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemVaultAggregatedVaultItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemVaultAggregatedVaultItem.cs
index abbb07599..0524e8257 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemVaultAggregatedVaultItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemVaultAggregatedVaultItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemVaultAggregatedVaultItemAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemVaultAggregatedVaultItemAllOf.cs
index 028e60d4c..0f72b1244 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemVaultAggregatedVaultItemAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NonFungibleResourcesCollectionItemVaultAggregatedVaultItemAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NotSyncedUpError.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NotSyncedUpError.cs
index ce67679bb..26c2fe574 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NotSyncedUpError.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NotSyncedUpError.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NotSyncedUpErrorAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NotSyncedUpErrorAllOf.cs
index 5984d3c17..3c80f46a9 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NotSyncedUpErrorAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/NotSyncedUpErrorAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ObjectModuleId.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ObjectModuleId.cs
index 3acd127d0..3c139fad6 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ObjectModuleId.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ObjectModuleId.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/OptionalNonFungibleIdsCollection.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/OptionalNonFungibleIdsCollection.cs
index 1cd2007aa..4640dcd22 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/OptionalNonFungibleIdsCollection.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/OptionalNonFungibleIdsCollection.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/OptionalNonFungibleIdsCollectionAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/OptionalNonFungibleIdsCollectionAllOf.cs
index b9ccd604a..c1b839a4b 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/OptionalNonFungibleIdsCollectionAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/OptionalNonFungibleIdsCollectionAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PackageBlueprintCollection.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PackageBlueprintCollection.cs
index 0a3dd6975..c78e7655c 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PackageBlueprintCollection.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PackageBlueprintCollection.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PackageBlueprintCollectionAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PackageBlueprintCollectionAllOf.cs
index 57955ce1c..c91949567 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PackageBlueprintCollectionAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PackageBlueprintCollectionAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PackageBlueprintCollectionItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PackageBlueprintCollectionItem.cs
index 976c4b6ec..eb482e04e 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PackageBlueprintCollectionItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PackageBlueprintCollectionItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PackageCodeCollection.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PackageCodeCollection.cs
index 875636c07..6894822d4 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PackageCodeCollection.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PackageCodeCollection.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PackageCodeCollectionAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PackageCodeCollectionAllOf.cs
index 09562c85e..9d8ace517 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PackageCodeCollectionAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PackageCodeCollectionAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PackageCodeCollectionItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PackageCodeCollectionItem.cs
index 88a480044..eaba9ce6f 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PackageCodeCollectionItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PackageCodeCollectionItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PackageVmType.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PackageVmType.cs
index 88d3fb4d3..cc8d3adb9 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PackageVmType.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PackageVmType.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValue.cs
index 830951036..6fc12660f 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueArray.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueArray.cs
index 26f5ecd94..926aa8416 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueArray.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueArray.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueArrayAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueArrayAllOf.cs
index 2e093317b..d69f3ed49 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueArrayAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueArrayAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueBool.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueBool.cs
index ad9c4bdaa..6573b7a7c 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueBool.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueBool.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueBytes.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueBytes.cs
index a6c4d7d85..8085394d5 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueBytes.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueBytes.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueBytesAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueBytesAllOf.cs
index fc1bdb896..a7ed4492b 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueBytesAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueBytesAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueDecimal.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueDecimal.cs
index 2ef35e826..e97be8920 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueDecimal.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueDecimal.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueEnum.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueEnum.cs
index 4d89505a4..ca4ea7ed6 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueEnum.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueEnum.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueEnumAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueEnumAllOf.cs
index e39195588..aea1baaee 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueEnumAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueEnumAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueI128.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueI128.cs
index 1822ea0fa..3777638c2 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueI128.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueI128.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueI16.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueI16.cs
index 2e88141d0..b8b967ac4 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueI16.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueI16.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueI32.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueI32.cs
index f5354994c..c3148bf48 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueI32.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueI32.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueI64.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueI64.cs
index a44237370..f3a352a79 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueI64.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueI64.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueI8.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueI8.cs
index 9121c1e7b..0302b381c 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueI8.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueI8.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueKind.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueKind.cs
index 331db4da3..e56906a41 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueKind.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueKind.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueMap.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueMap.cs
index 841c01ecd..cb40f8e0e 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueMap.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueMap.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueMapAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueMapAllOf.cs
index 7a9fbd3c5..3a085e960 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueMapAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueMapAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueMapEntry.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueMapEntry.cs
index 31b6a089e..3996efe82 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueMapEntry.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueMapEntry.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueNonFungibleLocalId.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueNonFungibleLocalId.cs
index cf3638c65..8520e5507 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueNonFungibleLocalId.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueNonFungibleLocalId.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueOwn.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueOwn.cs
index 9a3af9a6b..ffb19d04e 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueOwn.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueOwn.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValuePreciseDecimal.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValuePreciseDecimal.cs
index d24ad7e93..54033b059 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValuePreciseDecimal.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValuePreciseDecimal.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueReference.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueReference.cs
index 69d6ecce5..51d1b8f0f 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueReference.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueReference.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueReferenceAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueReferenceAllOf.cs
index d09167054..237863703 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueReferenceAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueReferenceAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueString.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueString.cs
index d53776a5e..2e0c71a4d 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueString.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueString.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueTuple.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueTuple.cs
index 4dbde169a..5836e640b 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueTuple.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueTuple.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueTupleAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueTupleAllOf.cs
index fda547ef3..bf4b58860 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueTupleAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueTupleAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueU128.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueU128.cs
index ed1443e3e..964c9ebdf 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueU128.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueU128.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueU16.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueU16.cs
index e1c423713..a5a440116 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueU16.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueU16.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueU32.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueU32.cs
index 860316e55..a51afc1cd 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueU32.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueU32.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueU64.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueU64.cs
index 306166ebc..87242d248 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueU64.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueU64.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueU8.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueU8.cs
index 92734c143..a756ad84c 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueU8.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ProgrammaticScryptoSborValueU8.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKey.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKey.cs
index adaa282c6..c8fa0745f 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKey.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKey.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyEcdsaSecp256k1.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyEcdsaSecp256k1.cs
index ae7f4c7e9..6c25e1f9c 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyEcdsaSecp256k1.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyEcdsaSecp256k1.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyEcdsaSecp256k1AllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyEcdsaSecp256k1AllOf.cs
index 12afe8cde..048a44c28 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyEcdsaSecp256k1AllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyEcdsaSecp256k1AllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyEddsaEd25519.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyEddsaEd25519.cs
index 600e35b8a..29d7dca3c 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyEddsaEd25519.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyEddsaEd25519.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyEddsaEd25519AllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyEddsaEd25519AllOf.cs
index 77b81524e..c1daf54e7 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyEddsaEd25519AllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyEddsaEd25519AllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyHash.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyHash.cs
index 69774728f..5c1084270 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyHash.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyHash.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyHashEcdsaSecp256k1.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyHashEcdsaSecp256k1.cs
index 3772f4a10..a1dae484e 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyHashEcdsaSecp256k1.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyHashEcdsaSecp256k1.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyHashEcdsaSecp256k1AllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyHashEcdsaSecp256k1AllOf.cs
index 1598cdd19..daacf184e 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyHashEcdsaSecp256k1AllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyHashEcdsaSecp256k1AllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyHashEddsaEd25519.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyHashEddsaEd25519.cs
index 060560e19..56c881e50 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyHashEddsaEd25519.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyHashEddsaEd25519.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyHashType.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyHashType.cs
index 5752900e7..26457b842 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyHashType.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyHashType.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyType.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyType.cs
index f53d0fa16..01dea8a53 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyType.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/PublicKeyType.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceAggregationLevel.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceAggregationLevel.cs
index ae7c4cc89..64575cd4e 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceAggregationLevel.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceAggregationLevel.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersCollection.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersCollection.cs
index 4cef2e512..a69adb3b6 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersCollection.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersCollection.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersCollectionAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersCollectionAllOf.cs
index 1c30cc1b4..ede12e5f3 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersCollectionAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersCollectionAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersCollectionFungibleResourceItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersCollectionFungibleResourceItem.cs
index 3f280df98..3cd56dfec 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersCollectionFungibleResourceItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersCollectionFungibleResourceItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersCollectionItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersCollectionItem.cs
index 55ab393eb..2fb2e75fd 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersCollectionItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersCollectionItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersCollectionNonFungibleResourceItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersCollectionNonFungibleResourceItem.cs
index a6ea1ed46..b97d574e1 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersCollectionNonFungibleResourceItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersCollectionNonFungibleResourceItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersCollectionNonFungibleResourceItemAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersCollectionNonFungibleResourceItemAllOf.cs
index ab42d6345..e1d3eb64c 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersCollectionNonFungibleResourceItemAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersCollectionNonFungibleResourceItemAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersRequest.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersRequest.cs
index 6a72a6092..124649e94 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersRequest.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersRequest.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersRequestAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersRequestAllOf.cs
index fea612ac4..e139cb294 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersRequestAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersRequestAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersResourceType.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersResourceType.cs
index c80f808b3..7d09dfbf5 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersResourceType.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersResourceType.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersResponse.cs
index c51c41ad1..d5feeef1f 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResourceHoldersResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResultSetCursorMixin.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResultSetCursorMixin.cs
index bf4ed6ac8..6fed981b5 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResultSetCursorMixin.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ResultSetCursorMixin.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/RoleAssignmentResolution.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/RoleAssignmentResolution.cs
index d8fb4f02a..917363515 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/RoleAssignmentResolution.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/RoleAssignmentResolution.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/RoleKey.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/RoleKey.cs
index 916f7575b..f38683ea1 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/RoleKey.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/RoleKey.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/RoyaltyAmount.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/RoyaltyAmount.cs
index 3e68f87cc..c520f45c5 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/RoyaltyAmount.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/RoyaltyAmount.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ScryptoSborValue.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ScryptoSborValue.cs
index a90a54ea3..a99ec4ef4 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ScryptoSborValue.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ScryptoSborValue.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountAuthorizedDepositorsPageRequest.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountAuthorizedDepositorsPageRequest.cs
index e2bbb5f18..2fa80111e 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountAuthorizedDepositorsPageRequest.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountAuthorizedDepositorsPageRequest.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountAuthorizedDepositorsPageResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountAuthorizedDepositorsPageResponse.cs
index 29238214f..5acdec413 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountAuthorizedDepositorsPageResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountAuthorizedDepositorsPageResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockerPageVaultsRequest.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockerPageVaultsRequest.cs
index cc34c81ad..8c449e66a 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockerPageVaultsRequest.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockerPageVaultsRequest.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockerPageVaultsResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockerPageVaultsResponse.cs
index 1c4bf075e..3063c685b 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockerPageVaultsResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockerPageVaultsResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockersTouchedAtRequest.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockersTouchedAtRequest.cs
index 100d8cd29..ac8f73d36 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockersTouchedAtRequest.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockersTouchedAtRequest.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockersTouchedAtRequestAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockersTouchedAtRequestAllOf.cs
index 960897aa2..f745771e7 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockersTouchedAtRequestAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockersTouchedAtRequestAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockersTouchedAtResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockersTouchedAtResponse.cs
index 66fa7585e..8014549c7 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockersTouchedAtResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockersTouchedAtResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockersTouchedAtResponseAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockersTouchedAtResponseAllOf.cs
index 2049da3e7..fd9fbc451 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockersTouchedAtResponseAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockersTouchedAtResponseAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockersTouchedAtResponseItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockersTouchedAtResponseItem.cs
index 8ab6dd5b4..c2f5e7ab6 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockersTouchedAtResponseItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockersTouchedAtResponseItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockersTouchedAtResponseItemAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockersTouchedAtResponseItemAllOf.cs
index cb93ff74b..bfd0edc09 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockersTouchedAtResponseItemAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountLockersTouchedAtResponseItemAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountResourcePreferencesPageRequest.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountResourcePreferencesPageRequest.cs
index 45ce51ba4..885395792 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountResourcePreferencesPageRequest.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountResourcePreferencesPageRequest.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountResourcePreferencesPageRequestAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountResourcePreferencesPageRequestAllOf.cs
index 00f343a7d..ecac31ed7 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountResourcePreferencesPageRequestAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountResourcePreferencesPageRequestAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountResourcePreferencesPageResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountResourcePreferencesPageResponse.cs
index de2a9e6de..20a88cfeb 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountResourcePreferencesPageResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateAccountResourcePreferencesPageResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsOptIns.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsOptIns.cs
index 406b79a77..315a3ffb7 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsOptIns.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsOptIns.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsRequest.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsRequest.cs
index f03db5e45..feb279119 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsRequest.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsRequest.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsRequestAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsRequestAllOf.cs
index 212f49576..adb257a14 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsRequestAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsRequestAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponse.cs
index 3856ebf56..7802f3a19 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseAllOf.cs
index 641ba5ea2..6af77a429 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseComponentDetails.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseComponentDetails.cs
index f8492c216..9060394f1 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseComponentDetails.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseComponentDetails.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseComponentDetailsAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseComponentDetailsAllOf.cs
index d260f260d..441a4868d 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseComponentDetailsAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseComponentDetailsAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseFungibleResourceDetails.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseFungibleResourceDetails.cs
index b41dcebec..3ebd56f93 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseFungibleResourceDetails.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseFungibleResourceDetails.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseFungibleResourceDetailsAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseFungibleResourceDetailsAllOf.cs
index 3b637f68d..88b9a3ccc 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseFungibleResourceDetailsAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseFungibleResourceDetailsAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseFungibleVaultDetails.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseFungibleVaultDetails.cs
index 86afcd648..c4b5b34c1 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseFungibleVaultDetails.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseFungibleVaultDetails.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseFungibleVaultDetailsAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseFungibleVaultDetailsAllOf.cs
index a0277d5c6..793b07925 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseFungibleVaultDetailsAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseFungibleVaultDetailsAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseItem.cs
index e8e3dc949..437bb6314 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseItemAncestorIdentities.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseItemAncestorIdentities.cs
index 5c552af83..d584c3129 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseItemAncestorIdentities.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseItemAncestorIdentities.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseItemDetails.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseItemDetails.cs
index aa78526f4..b614230e9 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseItemDetails.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseItemDetails.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseItemDetailsType.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseItemDetailsType.cs
index 320a07ab5..f569c11f5 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseItemDetailsType.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseItemDetailsType.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseNonFungibleResourceDetails.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseNonFungibleResourceDetails.cs
index 6dabf905a..f8f6db7be 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseNonFungibleResourceDetails.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseNonFungibleResourceDetails.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseNonFungibleResourceDetailsAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseNonFungibleResourceDetailsAllOf.cs
index f0b02352b..377db0923 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseNonFungibleResourceDetailsAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseNonFungibleResourceDetailsAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseNonFungibleVaultDetails.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseNonFungibleVaultDetails.cs
index ea52dc013..d807503b1 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseNonFungibleVaultDetails.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseNonFungibleVaultDetails.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseNonFungibleVaultDetailsAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseNonFungibleVaultDetailsAllOf.cs
index c92f14983..8399f3dc1 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseNonFungibleVaultDetailsAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponseNonFungibleVaultDetailsAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponsePackageDetails.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponsePackageDetails.cs
index 21fd14558..3ea8cb4b3 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponsePackageDetails.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponsePackageDetails.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponsePackageDetailsAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponsePackageDetailsAllOf.cs
index c0dcf437e..3c9fb38a4 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponsePackageDetailsAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityDetailsResponsePackageDetailsAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityFungibleResourceVaultsPageRequest.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityFungibleResourceVaultsPageRequest.cs
index 9f011f39b..f9472ca7e 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityFungibleResourceVaultsPageRequest.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityFungibleResourceVaultsPageRequest.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityFungibleResourceVaultsPageRequestAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityFungibleResourceVaultsPageRequestAllOf.cs
index 851abd602..2ec50d2cd 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityFungibleResourceVaultsPageRequestAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityFungibleResourceVaultsPageRequestAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityFungibleResourceVaultsPageResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityFungibleResourceVaultsPageResponse.cs
index 319e2488a..cf8147b6a 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityFungibleResourceVaultsPageResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityFungibleResourceVaultsPageResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityFungiblesPageRequest.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityFungiblesPageRequest.cs
index 517d6352d..652f1cfe5 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityFungiblesPageRequest.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityFungiblesPageRequest.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityFungiblesPageRequestAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityFungiblesPageRequestAllOf.cs
index e2e72085b..659b432fc 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityFungiblesPageRequestAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityFungiblesPageRequestAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityFungiblesPageRequestOptIns.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityFungiblesPageRequestOptIns.cs
index 30636356e..c6386881d 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityFungiblesPageRequestOptIns.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityFungiblesPageRequestOptIns.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityFungiblesPageResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityFungiblesPageResponse.cs
index a222ad233..9b0b2e9cb 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityFungiblesPageResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityFungiblesPageResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityMetadataPageRequest.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityMetadataPageRequest.cs
index 6fc450218..9eb4e150c 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityMetadataPageRequest.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityMetadataPageRequest.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityMetadataPageRequestAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityMetadataPageRequestAllOf.cs
index 2a74bee5f..02eed173c 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityMetadataPageRequestAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityMetadataPageRequestAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityMetadataPageResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityMetadataPageResponse.cs
index 3464d6a7d..6f39be2dd 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityMetadataPageResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityMetadataPageResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungibleIdsPageRequest.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungibleIdsPageRequest.cs
index 652c42dce..115e2ed43 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungibleIdsPageRequest.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungibleIdsPageRequest.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungibleIdsPageRequestAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungibleIdsPageRequestAllOf.cs
index c4f83ff87..ac84b5df4 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungibleIdsPageRequestAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungibleIdsPageRequestAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungibleIdsPageResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungibleIdsPageResponse.cs
index 8f8284e7d..aaae84131 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungibleIdsPageResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungibleIdsPageResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungibleResourceVaultsPageOptIns.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungibleResourceVaultsPageOptIns.cs
index 1d1c2cedb..5b13659d4 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungibleResourceVaultsPageOptIns.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungibleResourceVaultsPageOptIns.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungibleResourceVaultsPageRequest.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungibleResourceVaultsPageRequest.cs
index b8392be05..c564464ec 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungibleResourceVaultsPageRequest.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungibleResourceVaultsPageRequest.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungibleResourceVaultsPageRequestAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungibleResourceVaultsPageRequestAllOf.cs
index f8fde63fb..8dbb9db1f 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungibleResourceVaultsPageRequestAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungibleResourceVaultsPageRequestAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungibleResourceVaultsPageResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungibleResourceVaultsPageResponse.cs
index 6ffbea3df..317a9e45f 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungibleResourceVaultsPageResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungibleResourceVaultsPageResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungiblesPageRequest.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungiblesPageRequest.cs
index c09c388ba..1b1ae9cf8 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungiblesPageRequest.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungiblesPageRequest.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungiblesPageRequestAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungiblesPageRequestAllOf.cs
index 021258bfd..c5c202c0c 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungiblesPageRequestAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungiblesPageRequestAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungiblesPageRequestOptIns.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungiblesPageRequestOptIns.cs
index a30772555..adc31b505 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungiblesPageRequestOptIns.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungiblesPageRequestOptIns.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungiblesPageResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungiblesPageResponse.cs
index 20a69c1ed..05f346b70 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungiblesPageResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntityNonFungiblesPageResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntitySchemaPageRequest.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntitySchemaPageRequest.cs
index 00646cbf2..a48a41b72 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntitySchemaPageRequest.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntitySchemaPageRequest.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntitySchemaPageResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntitySchemaPageResponse.cs
index e844516e1..7a082e5c4 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntitySchemaPageResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateEntitySchemaPageResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreDataRequest.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreDataRequest.cs
index 7da9b8f0e..1925a8785 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreDataRequest.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreDataRequest.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreDataRequestAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreDataRequestAllOf.cs
index d94440bd4..f1b7658c6 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreDataRequestAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreDataRequestAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreDataRequestKeyItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreDataRequestKeyItem.cs
index 9b9ad40e5..26209bed3 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreDataRequestKeyItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreDataRequestKeyItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreDataResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreDataResponse.cs
index 0040906de..8323b7da1 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreDataResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreDataResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreDataResponseAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreDataResponseAllOf.cs
index 1ebb92bf1..279cfef4a 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreDataResponseAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreDataResponseAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreDataResponseItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreDataResponseItem.cs
index 6c7ba4aa4..ed32085d5 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreDataResponseItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreDataResponseItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreKeysCollection.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreKeysCollection.cs
index f7e03d6ec..51cf0c894 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreKeysCollection.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreKeysCollection.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreKeysCollectionAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreKeysCollectionAllOf.cs
index e9d1874cd..d06384aab 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreKeysCollectionAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreKeysCollectionAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreKeysRequest.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreKeysRequest.cs
index ce3f8b005..8921bef33 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreKeysRequest.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreKeysRequest.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreKeysRequestAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreKeysRequestAllOf.cs
index 2de654975..47237dbeb 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreKeysRequestAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreKeysRequestAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreKeysResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreKeysResponse.cs
index 37d498ad2..0d936907d 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreKeysResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreKeysResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreKeysResponseItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreKeysResponseItem.cs
index 3d9821f53..1eb9d056c 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreKeysResponseItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateKeyValueStoreKeysResponseItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleDataRequest.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleDataRequest.cs
index a83ff7a48..98d3bbfe6 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleDataRequest.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleDataRequest.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleDataResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleDataResponse.cs
index 27ca37109..6d25e02f9 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleDataResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleDataResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleDataResponseAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleDataResponseAllOf.cs
index a84fc0caf..0bc777a8e 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleDataResponseAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleDataResponseAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleDetailsResponseItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleDetailsResponseItem.cs
index 7acdb44fd..daef7160b 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleDetailsResponseItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleDetailsResponseItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleIdsRequest.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleIdsRequest.cs
index dd6cb3ac3..877239d31 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleIdsRequest.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleIdsRequest.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleIdsRequestAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleIdsRequestAllOf.cs
index 66899eee3..3b2fca5da 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleIdsRequestAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleIdsRequestAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleIdsResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleIdsResponse.cs
index 7b0e11fa7..9de6dd649 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleIdsResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleIdsResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleIdsResponseAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleIdsResponseAllOf.cs
index d5fb1bde6..88d8bdfcd 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleIdsResponseAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleIdsResponseAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleLocationRequest.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleLocationRequest.cs
index f2d31ddbb..7fd2c99cf 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleLocationRequest.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleLocationRequest.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleLocationRequestAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleLocationRequestAllOf.cs
index 399dc8e12..7bfe2c07e 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleLocationRequestAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleLocationRequestAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleLocationResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleLocationResponse.cs
index 98e3be57c..ab95e65ba 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleLocationResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleLocationResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleLocationResponseAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleLocationResponseAllOf.cs
index 3b654789b..510566db0 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleLocationResponseAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleLocationResponseAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleLocationResponseItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleLocationResponseItem.cs
index c82d74039..c8dfa1917 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleLocationResponseItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateNonFungibleLocationResponseItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StatePackageBlueprintPageRequest.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StatePackageBlueprintPageRequest.cs
index 3f798668b..09d21e918 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StatePackageBlueprintPageRequest.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StatePackageBlueprintPageRequest.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StatePackageBlueprintPageRequestAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StatePackageBlueprintPageRequestAllOf.cs
index 47c04e4bc..3b37bf8d8 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StatePackageBlueprintPageRequestAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StatePackageBlueprintPageRequestAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StatePackageBlueprintPageResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StatePackageBlueprintPageResponse.cs
index 2b55517e1..0fbd8371b 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StatePackageBlueprintPageResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StatePackageBlueprintPageResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StatePackageCodePageRequest.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StatePackageCodePageRequest.cs
index 7b83ea1aa..30f8303c3 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StatePackageCodePageRequest.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StatePackageCodePageRequest.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StatePackageCodePageResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StatePackageCodePageResponse.cs
index d687e5fdd..4b5997d16 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StatePackageCodePageResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StatePackageCodePageResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateValidatorsListRequest.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateValidatorsListRequest.cs
index 2764ab999..15e37df86 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateValidatorsListRequest.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateValidatorsListRequest.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateValidatorsListRequestAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateValidatorsListRequestAllOf.cs
index 3bc640764..6b4625c9f 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateValidatorsListRequestAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateValidatorsListRequestAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateValidatorsListResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateValidatorsListResponse.cs
index 723549036..f34bc9d68 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateValidatorsListResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateValidatorsListResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateValidatorsListResponseAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateValidatorsListResponseAllOf.cs
index 6716c9eb0..8e264831b 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateValidatorsListResponseAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StateValidatorsListResponseAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StreamTransactionsRequest.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StreamTransactionsRequest.cs
index b9f6342b8..d72d09eb0 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StreamTransactionsRequest.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StreamTransactionsRequest.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StreamTransactionsRequestAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StreamTransactionsRequestAllOf.cs
index d63bf3677..9825779e2 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StreamTransactionsRequestAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StreamTransactionsRequestAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StreamTransactionsRequestAllOfManifestClassFilter.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StreamTransactionsRequestAllOfManifestClassFilter.cs
index 8ff7a533d..2adf645e1 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StreamTransactionsRequestAllOfManifestClassFilter.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StreamTransactionsRequestAllOfManifestClassFilter.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StreamTransactionsRequestEventFilterItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StreamTransactionsRequestEventFilterItem.cs
index c15d64c94..6bc1759a8 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StreamTransactionsRequestEventFilterItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StreamTransactionsRequestEventFilterItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StreamTransactionsResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StreamTransactionsResponse.cs
index 4a506602f..38cb3b97e 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StreamTransactionsResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StreamTransactionsResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StreamTransactionsResponseAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StreamTransactionsResponseAllOf.cs
index 3600a6d65..d8df167dd 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StreamTransactionsResponseAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/StreamTransactionsResponseAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionAccountDepositPreValidationAuthorizedDepositorBadge.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionAccountDepositPreValidationAuthorizedDepositorBadge.cs
index 15171fd01..ed662f190 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionAccountDepositPreValidationAuthorizedDepositorBadge.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionAccountDepositPreValidationAuthorizedDepositorBadge.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionBalanceChanges.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionBalanceChanges.cs
index b8b054d2e..46322ac9d 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionBalanceChanges.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionBalanceChanges.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionCommittedDetailsRequest.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionCommittedDetailsRequest.cs
index 07015d163..119078353 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionCommittedDetailsRequest.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionCommittedDetailsRequest.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionCommittedDetailsRequestAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionCommittedDetailsRequestAllOf.cs
index f0de8f5e7..428229c68 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionCommittedDetailsRequestAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionCommittedDetailsRequestAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionCommittedDetailsResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionCommittedDetailsResponse.cs
index d05eb9f1c..9fc7a5528 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionCommittedDetailsResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionCommittedDetailsResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionCommittedDetailsResponseAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionCommittedDetailsResponseAllOf.cs
index 151b61d9c..418b03252 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionCommittedDetailsResponseAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionCommittedDetailsResponseAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionConstructionResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionConstructionResponse.cs
index 7a8e8ddf3..50391c240 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionConstructionResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionConstructionResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionDetailsOptIns.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionDetailsOptIns.cs
index b6d18e6e6..bc065d12d 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionDetailsOptIns.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionDetailsOptIns.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionFungibleBalanceChanges.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionFungibleBalanceChanges.cs
index 024d01758..f123927ba 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionFungibleBalanceChanges.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionFungibleBalanceChanges.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionFungibleFeeBalanceChangeType.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionFungibleFeeBalanceChangeType.cs
index 67ada4696..2e2908b10 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionFungibleFeeBalanceChangeType.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionFungibleFeeBalanceChangeType.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionFungibleFeeBalanceChanges.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionFungibleFeeBalanceChanges.cs
index 682a22c21..cd2040411 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionFungibleFeeBalanceChanges.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionFungibleFeeBalanceChanges.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionIntentStatus.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionIntentStatus.cs
index 291156ae3..1d7f4f9e9 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionIntentStatus.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionIntentStatus.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionNonFungibleBalanceChanges.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionNonFungibleBalanceChanges.cs
index fbcafcd57..2f07632ac 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionNonFungibleBalanceChanges.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionNonFungibleBalanceChanges.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionNotFoundError.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionNotFoundError.cs
index f510f5235..c484394d8 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionNotFoundError.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionNotFoundError.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionPayloadGatewayHandlingStatus.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionPayloadGatewayHandlingStatus.cs
index a1c246a69..bb4b2f584 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionPayloadGatewayHandlingStatus.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionPayloadGatewayHandlingStatus.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionPayloadStatus.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionPayloadStatus.cs
index 751cb3cbc..683356724 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionPayloadStatus.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionPayloadStatus.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionPreviewOptIns.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionPreviewOptIns.cs
index 35f682148..04f743ef2 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionPreviewOptIns.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionPreviewOptIns.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionPreviewRequest.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionPreviewRequest.cs
index bd1032400..9cc465278 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionPreviewRequest.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionPreviewRequest.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionPreviewRequestFlags.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionPreviewRequestFlags.cs
index 948d45cfd..14c7ee01a 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionPreviewRequestFlags.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionPreviewRequestFlags.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionPreviewResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionPreviewResponse.cs
index b4654f1b9..34d656f45 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionPreviewResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionPreviewResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionPreviewResponseLogsInner.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionPreviewResponseLogsInner.cs
index a2cc3956d..60643d3e6 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionPreviewResponseLogsInner.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionPreviewResponseLogsInner.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionReceipt.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionReceipt.cs
index 713391b0d..c1a59dab8 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionReceipt.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionReceipt.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionStatus.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionStatus.cs
index da5cb21df..52ec1070e 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionStatus.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionStatus.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionStatusRequest.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionStatusRequest.cs
index 73657a41d..2e0e47b74 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionStatusRequest.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionStatusRequest.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionStatusRequestAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionStatusRequestAllOf.cs
index 4e9a374ba..73d76b196 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionStatusRequestAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionStatusRequestAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionStatusResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionStatusResponse.cs
index f7af19a27..4506e8cfc 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionStatusResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionStatusResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionStatusResponseAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionStatusResponseAllOf.cs
index 3db7968ba..053831e1b 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionStatusResponseAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionStatusResponseAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionStatusResponseKnownPayloadItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionStatusResponseKnownPayloadItem.cs
index 3c972bda9..e3554b7cb 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionStatusResponseKnownPayloadItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionStatusResponseKnownPayloadItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionSubmitRequest.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionSubmitRequest.cs
index b5a0df36b..f8bdb993e 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionSubmitRequest.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionSubmitRequest.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionSubmitResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionSubmitResponse.cs
index 6b3e9e258..cd9bbd3d4 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionSubmitResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TransactionSubmitResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TwoWayLinkedDappOnLedgerDetails.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TwoWayLinkedDappOnLedgerDetails.cs
index e10ac3e33..82f9210cf 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TwoWayLinkedDappOnLedgerDetails.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TwoWayLinkedDappOnLedgerDetails.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TwoWayLinkedDappsCollection.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TwoWayLinkedDappsCollection.cs
index 78aee0082..ae2b10280 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TwoWayLinkedDappsCollection.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TwoWayLinkedDappsCollection.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TwoWayLinkedDappsCollectionItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TwoWayLinkedDappsCollectionItem.cs
index 9e9bca225..efb117f72 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TwoWayLinkedDappsCollectionItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TwoWayLinkedDappsCollectionItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TwoWayLinkedEntitiesCollection.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TwoWayLinkedEntitiesCollection.cs
index ec83f9ab2..614fb10af 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TwoWayLinkedEntitiesCollection.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TwoWayLinkedEntitiesCollection.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TwoWayLinkedEntitiesCollectionItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TwoWayLinkedEntitiesCollectionItem.cs
index 52e6c22f2..99bd231e2 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TwoWayLinkedEntitiesCollectionItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/TwoWayLinkedEntitiesCollectionItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidationErrorsAtPath.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidationErrorsAtPath.cs
index d0e002b98..482fed556 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidationErrorsAtPath.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidationErrorsAtPath.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorCollection.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorCollection.cs
index 025f3eb34..656175680 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorCollection.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorCollection.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorCollectionAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorCollectionAllOf.cs
index f08151a29..12895f6a8 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorCollectionAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorCollectionAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorCollectionItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorCollectionItem.cs
index 58475d744..af786a2a7 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorCollectionItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorCollectionItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorCollectionItemActiveInEpoch.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorCollectionItemActiveInEpoch.cs
index 05be53e86..128cb4890 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorCollectionItemActiveInEpoch.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorCollectionItemActiveInEpoch.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorCollectionItemEffectiveFeeFactor.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorCollectionItemEffectiveFeeFactor.cs
index 74ebee810..1d4b40e11 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorCollectionItemEffectiveFeeFactor.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorCollectionItemEffectiveFeeFactor.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorCollectionItemEffectiveFeeFactorCurrent.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorCollectionItemEffectiveFeeFactorCurrent.cs
index 8d9f4ce73..2ace91fcd 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorCollectionItemEffectiveFeeFactorCurrent.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorCollectionItemEffectiveFeeFactorCurrent.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorCollectionItemEffectiveFeeFactorPending.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorCollectionItemEffectiveFeeFactorPending.cs
index 7ef4b81b6..1849006c0 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorCollectionItemEffectiveFeeFactorPending.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorCollectionItemEffectiveFeeFactorPending.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorUptimeCollection.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorUptimeCollection.cs
index 9e6ac2a18..771147ea7 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorUptimeCollection.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorUptimeCollection.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorUptimeCollectionItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorUptimeCollectionItem.cs
index cf9397a10..a9dc6ec2c 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorUptimeCollectionItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorUptimeCollectionItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorVaultItem.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorVaultItem.cs
index fb280329b..243d7dd92 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorVaultItem.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorVaultItem.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorsUptimeRequest.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorsUptimeRequest.cs
index e03ac197c..73715f6bf 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorsUptimeRequest.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorsUptimeRequest.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorsUptimeRequestAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorsUptimeRequestAllOf.cs
index ce1c1798c..5d59a91cf 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorsUptimeRequestAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorsUptimeRequestAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorsUptimeResponse.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorsUptimeResponse.cs
index 31bbcfc44..78f1bc017 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorsUptimeResponse.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorsUptimeResponse.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorsUptimeResponseAllOf.cs b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorsUptimeResponseAllOf.cs
index 013329293..82be75ae3 100644
--- a/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorsUptimeResponseAllOf.cs
+++ b/src/RadixDlt.NetworkGateway.GatewayApiSdk/generated/Model/ValidatorsUptimeResponseAllOf.cs
@@ -67,7 +67,7 @@
  *
  * This API is exposed by the Babylon Radix Gateway to enable clients to efficiently query current and historic state on the RadixDLT ledger, and intelligently handle transaction submission.  It is designed for use by wallets and explorers, and for light queries from front-end dApps. For exchange/asset integrations, back-end dApp integrations, or simple use cases, you should consider using the Core API on a Node. A Gateway is only needed for reading historic snapshots of ledger states or a more robust set-up.  The Gateway API is implemented by the [Network Gateway](https://github.com/radixdlt/babylon-gateway), which is configured to read from [full node(s)](https://github.com/radixdlt/babylon-node) to extract and index data from the network.  This document is an API reference documentation, visit [User Guide](https://docs.radixdlt.com/) to learn more about how to run a Gateway of your own.  ## Migration guide  Please see [the latest release notes](https://github.com/radixdlt/babylon-gateway/releases).  ## Integration and forward compatibility guarantees  All responses may have additional fields added at any release, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.  When the Radix protocol is updated, new functionality may be added, and so discriminated unions returned by the API may need to be updated to have new variants added, corresponding to the updated data. Clients may need to update in advance to be able to handle these new variants when a protocol update comes out.  On the very rare occasions we need to make breaking changes to the API, these will be warned in advance with deprecation notices on previous versions. These deprecation notices will include a safe migration path. Deprecation notes or breaking changes will be flagged clearly in release notes for new versions of the Gateway.  The Gateway DB schema is not subject to any compatibility guarantees, and may be changed at any release. DB changes will be flagged in the release notes so clients doing custom DB integrations can prepare. 
  *
- * The version of the OpenAPI document: v1.8.1
+ * The version of the OpenAPI document: v1.8.2
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
diff --git a/src/RadixDlt.NetworkGateway.PostgresIntegration/LedgerExtension/Processors/VaultProcessor.cs b/src/RadixDlt.NetworkGateway.PostgresIntegration/LedgerExtension/Processors/VaultProcessor.cs
index 874cb8967..6c8f9678b 100644
--- a/src/RadixDlt.NetworkGateway.PostgresIntegration/LedgerExtension/Processors/VaultProcessor.cs
+++ b/src/RadixDlt.NetworkGateway.PostgresIntegration/LedgerExtension/Processors/VaultProcessor.cs
@@ -84,13 +84,13 @@ internal class VaultProcessor : IProcessorBase, ISubstateUpsertProcessor, ISubst
 
     private readonly record struct NonFungibleVaultChange(VaultEntity VaultEntity, string NonFungibleLocalId, bool IsDeposit, long StateVersion);
 
-    private readonly record struct NonFungibleIdChange(bool IsDeleted, bool IsLocked, byte[]? MutableData, long StateVersion);
+    private readonly record struct NonFungibleIdChange(long NonFungibleResourceEntityId, string NonFungibleId, bool IsDeleted, bool IsLocked, byte[]? MutableData, long StateVersion);
 
     private readonly ProcessorContext _context;
 
     private readonly List<VaultBalanceSnapshot> _observedVaultBalanceSnapshots = new();
     private readonly List<NonFungibleVaultChange> _observedNonFungibleVaultChanges = new();
-    private readonly Dictionary<NonFungibleIdDefinitionDbLookup, NonFungibleIdChange> _observedNonFungibleDataEntries = new();
+    private readonly List<NonFungibleIdChange> _observedNonFungibleDataChanges = new();
     private readonly Dictionary<NonFungibleIdDefinitionDbLookup, NonFungibleIdDefinition> _existingNonFungibleIdDefinitions = new();
     private readonly Dictionary<NonFungibleVaultEntryDefinitionDbLookup, NonFungibleVaultEntryDefinition> _existingNonFungibleVaultEntryDefinitions = new();
     private readonly List<VaultBalanceHistory> _balanceHistoryToAdd = new();
@@ -129,9 +129,10 @@ public void VisitUpsert(CoreModel.IUpsertedSubstate substate, ReferencedEntity r
         {
             var nonFungibleId = ScryptoSborUtils.GetNonFungibleId(((CoreModel.MapSubstateKey)substate.SubstateId.SubstateKey).KeyHex);
 
-            _observedNonFungibleDataEntries.TryAdd(
-                new NonFungibleIdDefinitionDbLookup(referencedEntity.DatabaseId, nonFungibleId),
+            _observedNonFungibleDataChanges.Add(
                 new NonFungibleIdChange(
+                    referencedEntity.DatabaseId,
+                    nonFungibleId,
                     nonFungibleResourceManagerDataEntrySubstate.Value == null,
                     nonFungibleResourceManagerDataEntrySubstate.IsLocked,
                     nonFungibleResourceManagerDataEntrySubstate.Value?.DataStruct.StructData.GetDataBytes(),
@@ -176,8 +177,10 @@ public void ProcessChanges()
                     Balance = x.Balance,
                 }));
 
-        foreach (var (lookup, nonFungibleIdChange) in _observedNonFungibleDataEntries)
+        foreach (var nonFungibleIdDataChange in _observedNonFungibleDataChanges)
         {
+            var lookup = new NonFungibleIdDefinitionDbLookup(nonFungibleIdDataChange.NonFungibleResourceEntityId, nonFungibleIdDataChange.NonFungibleId);
+
             var definition = _existingNonFungibleIdDefinitions.GetOrAdd(
                 lookup,
                 _ =>
@@ -185,7 +188,7 @@ public void ProcessChanges()
                     var definition = new NonFungibleIdDefinition
                     {
                         Id = _context.Sequences.NonFungibleIdDefinitionSequence++,
-                        FromStateVersion = nonFungibleIdChange.StateVersion,
+                        FromStateVersion = nonFungibleIdDataChange.StateVersion,
                         NonFungibleResourceEntityId = lookup.NonFungibleResourceEntityId,
                         NonFungibleId = lookup.NonFungibleId,
                     };
@@ -199,11 +202,11 @@ public void ProcessChanges()
                 new NonFungibleIdDataHistory
                 {
                     Id = _context.Sequences.NonFungibleIdDataHistorySequence++,
-                    FromStateVersion = nonFungibleIdChange.StateVersion,
+                    FromStateVersion = nonFungibleIdDataChange.StateVersion,
                     NonFungibleIdDefinitionId = definition.Id,
-                    Data = nonFungibleIdChange.MutableData,
-                    IsDeleted = nonFungibleIdChange.IsDeleted,
-                    IsLocked = nonFungibleIdChange.IsLocked,
+                    Data = nonFungibleIdDataChange.MutableData,
+                    IsDeleted = nonFungibleIdDataChange.IsDeleted,
+                    IsLocked = nonFungibleIdDataChange.IsLocked,
                 });
         }
 
@@ -282,13 +285,17 @@ public async Task<int> SaveEntitiesAsync()
 
     private async Task<IDictionary<NonFungibleIdDefinitionDbLookup, NonFungibleIdDefinition>> ExistingNonFungibleIdDefinitions()
     {
-        var lookup = _observedNonFungibleVaultChanges
+        var vaultChangesLookups = _observedNonFungibleVaultChanges
             .Select(x => new NonFungibleIdDefinitionDbLookup(x.VaultEntity.GetResourceEntityId(), x.NonFungibleLocalId))
             .ToHashSet();
 
-        lookup.UnionWith(_observedNonFungibleDataEntries.Keys);
+        var dataChangesLookups = _observedNonFungibleDataChanges
+            .Select(x => new NonFungibleIdDefinitionDbLookup(x.NonFungibleResourceEntityId, x.NonFungibleId))
+            .ToHashSet();
+
+        var lookups = vaultChangesLookups.Union(dataChangesLookups).ToHashSet();
 
-        if (!lookup.Unzip(x => x.NonFungibleResourceEntityId, x => x.NonFungibleId, out var resourceEntityIds, out var nonFungibleLocalIds))
+        if (!lookups.Unzip(x => x.NonFungibleResourceEntityId, x => x.NonFungibleId, out var resourceEntityIds, out var nonFungibleLocalIds))
         {
             return ImmutableDictionary<NonFungibleIdDefinitionDbLookup, NonFungibleIdDefinition>.Empty;
         }